cecli-dev 0.93.1__py3-none-any.whl

cecli/tui/widgets/status_bar.py

@@ -0,0 +1,279 @@
+"""Unified status bar widget for notifications and confirmations."""
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Static
+
+
+class StatusBar(Widget, can_focus=True):
+    """Unified status bar for notifications, confirmations, and prompts.
+
+    Modes:
+        - hidden: Bar is not displayed
+        - notification: Shows a transient message (auto-dismisses)
+        - confirm: Shows a y/n/a confirmation prompt
+    """
+
+    DEFAULT_CSS = """
+    StatusBar {
+        height: auto;
+        background: $surface;
+        margin: 0 0;
+        padding: 0;
+    }
+
+    StatusBar.hidden {
+        display: none;
+    }
+
+    /* Content container */
+    StatusBar .status-content {
+        height: 3;
+        padding: 1 0 0 2;
+        layout: horizontal;
+        align: left middle;
+        background: $surface;
+    }
+
+    /* Notification styles */
+    StatusBar .notification-text {
+        width: 1fr;
+        height: 1;
+        color: $secondary;
+        content-align: left middle;
+        background: $surface;
+    }
+
+    StatusBar .notification-text.info {
+        color: $secondary;
+    }
+
+    StatusBar .notification-text.warning {
+        color: $warning;
+    }
+
+    StatusBar .notification-text.error {
+        color: $error;
+    }
+
+    StatusBar .notification-text.success {
+        color: $success;
+    }
+
+    /* Confirmation styles */
+    StatusBar .confirm-question {
+        width: 1fr;
+        height: 1;
+        color: $foreground;
+        content-align: left middle;
+        background: $surface;
+    }
+
+    StatusBar .confirm-hints {
+        width: auto;
+        height: 1;
+        dock: right;
+        background: $surface;
+    }
+
+    StatusBar .hint {
+        width: auto;
+        height: 1;
+        margin-left: 2;
+        color: $secondary;
+        background: $surface;
+    }
+
+    StatusBar .hint-yes {
+        color: $success;
+    }
+
+    StatusBar .hint-no {
+        color: $warning;
+    }
+
+    StatusBar .hint-all {
+        color: $secondary;
+    }
+
+    StatusBar .hint-skip {
+        color: $secondary;
+    }
+
+    StatusBar .hint-tweak {
+        color: $accent;
+    }
+
+    StatusBar .hint-never {
+        color: $warning;
+    }
+    """
+
+    # Current mode
+    mode: reactive[str] = reactive("hidden")
+
+    class ConfirmResponse(Message):
+        """Confirmation response message."""
+
+        def __init__(self, result: bool | str):
+            self.result = result
+            super().__init__()
+
+    def __init__(self, **kwargs):
+        """Initialize status bar."""
+        super().__init__(**kwargs)
+        self._text = ""
+        self._severity = "info"
+        self._show_all = False
+        self._allow_tweak = False
+        self._allow_never = False
+        self._default = "y"
+        self._explicit_yes_required = False
+        self._timer = None
+
+    def compose(self) -> ComposeResult:
+        """Create empty container - content added dynamically."""
+        yield Horizontal(classes="status-content")
+
+    def watch_mode(self, mode: str) -> None:
+        """React to mode changes."""
+        self.remove_class("hidden")
+        if mode == "hidden":
+            self.add_class("hidden")
+            self.can_focus = False
+        else:
+            self.can_focus = mode == "confirm"
+
+    def _rebuild_content(self) -> None:
+        """Rebuild the content based on current mode."""
+        container = self.query_one(".status-content")
+        container.remove_children()
+
+        if self.mode == "notification":
+            container.mount(Static(self._text, classes=f"notification-text {self._severity}"))
+        elif self.mode == "confirm":
+            container.mount(Static(self._text, classes="confirm-question"))
+            hints = Horizontal(classes="confirm-hints")
+            container.mount(hints)
+            hints.mount(Static("\\[y]es", classes="hint hint-yes"))
+            hints.mount(Static("\\[n]o", classes="hint hint-no"))
+            if self._show_all:
+                hints.mount(Static("\\[a]ll", classes="hint hint-all"))
+                hints.mount(Static("\\[s]kip", classes="hint hint-skip"))
+            if self._allow_tweak:
+                hints.mount(Static("\\[t]weak", classes="hint hint-tweak"))
+            if self._allow_never:
+                hints.mount(Static("\\[d]on't ask", classes="hint hint-never"))
+
+    def show_notification(
+        self, text: str, severity: str = "info", timeout: float | None = 3.0
+    ) -> None:
+        """Show a transient notification message.
+
+        Args:
+            text: Message to display
+            severity: One of "info", "warning", "error", "success"
+            timeout: Auto-dismiss after this many seconds (None = no auto-dismiss)
+        """
+        # Cancel any existing timer
+        if self._timer:
+            self._timer.stop()
+            self._timer = None
+
+        self._text = text
+        self._severity = severity
+        self.mode = "notification"
+        self._rebuild_content()
+
+        if timeout:
+            self._timer = self.set_timer(timeout, self.hide)
+
+    def show_confirm(
+        self,
+        question: str,
+        show_all: bool = False,
+        allow_tweak: bool = False,
+        allow_never: bool = False,
+        default: str = "y",
+        explicit_yes_required: bool = False,
+    ) -> None:
+        """Show a confirmation prompt.
+
+        Args:
+            question: Question to display
+            show_all: Whether to show "all" option
+            allow_tweak: Whether to show "tweak" option
+            allow_never: Whether to show "don't ask again" option
+            default: Default response ("y" or "n")
+            explicit_yes_required: Whether explicit yes is required
+        """
+        # Cancel any existing timer
+        if self._timer:
+            self._timer.stop()
+            self._timer = None
+
+        self._text = question
+        self._show_all = show_all
+        self._allow_tweak = allow_tweak
+        self._allow_never = allow_never
+        self._default = default
+        self._explicit_yes_required = explicit_yes_required
+        self.mode = "confirm"
+        self._rebuild_content()
+        self.focus()
+
+    def hide(self) -> None:
+        """Hide the status bar."""
+        if self._timer:
+            self._timer.stop()
+            self._timer = None
+        self.mode = "hidden"
+
+    def on_key(self, event) -> None:
+        """Handle key shortcuts for confirm mode."""
+        if self.mode != "confirm":
+            return
+
+        key = event.key.lower()
+        if key == "y":
+            event.stop()
+            event.prevent_default()
+            self.post_message(self.ConfirmResponse(True))
+            self.hide()
+        elif key == "n":
+            event.stop()
+            event.prevent_default()
+            self.post_message(self.ConfirmResponse(False))
+            self.hide()
+        elif key == "a" and self._show_all:
+            event.stop()
+            event.prevent_default()
+            self.post_message(self.ConfirmResponse("all"))
+            self.hide()
+        elif key == "s" and self._show_all:
+            event.stop()
+            event.prevent_default()
+            self.post_message(self.ConfirmResponse("skip"))
+            self.hide()
+        elif key == "t" and self._allow_tweak:
+            event.stop()
+            event.prevent_default()
+            self.post_message(self.ConfirmResponse("tweak"))
+            self.hide()
+        elif key == "d" and self._allow_never:
+            event.stop()
+            event.prevent_default()
+            self.post_message(self.ConfirmResponse("never"))
+            self.hide()
+        elif key == "escape":
+            event.stop()
+            event.prevent_default()
+            # Return default based on default parameter
+            if self._default.lower().startswith("y"):
+                self.post_message(self.ConfirmResponse(True))
+            else:
+                self.post_message(self.ConfirmResponse(False))
+            self.hide()

cecli/tui/worker.py

@@ -0,0 +1,160 @@
+"""Worker thread for running Coder in background."""
+
+import asyncio
+import logging
+import threading
+import warnings
+from typing import Optional
+
+from cecli.coders import Coder
+from cecli.commands import SwitchCoderSignal
+
+# Suppress asyncio task destroyed warnings during shutdown
+logging.getLogger("asyncio").setLevel(logging.CRITICAL)
+
+# Also suppress via warnings module
+warnings.filterwarnings("ignore", message=".*Task was destroyed.*")
+warnings.filterwarnings("ignore", message=".*coroutine.*was never awaited.*")
+
+
+class CoderWorker:
+    """Runs Coder in a background thread with its own event loop."""
+
+    def __init__(self, coder, output_queue, input_queue):
+        """Initialize worker with coder instance and communication queues.
+
+        Args:
+            coder: The Coder instance to run
+            output_queue: queue.Queue for sending output to TUI
+            input_queue: queue.Queue for receiving input from TUI
+        """
+        self.coder = coder
+        self.output_queue = output_queue  # queue.Queue
+        self.input_queue = input_queue  # queue.Queue
+        self.thread: Optional[threading.Thread] = None
+        self.loop: Optional[asyncio.AbstractEventLoop] = None
+        self.running = False
+
+    def start(self):
+        """Start the worker thread."""
+        self.running = True
+        self.thread = threading.Thread(target=self._run_thread, daemon=True)
+        self.thread.start()
+
+    def _run_thread(self):
+        """Thread entry point - creates event loop and runs coder."""
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+
+        try:
+            self.loop.run_until_complete(self._async_run())
+        except asyncio.CancelledError:
+            pass
+        except RuntimeError:
+            # Event loop stopped - this is expected during shutdown
+            pass
+        finally:
+            self._cleanup_loop()
+
+    def _cleanup_loop(self):
+        """Clean up the event loop safely."""
+        if not self.loop:
+            return
+
+        try:
+            # Cancel pending tasks if loop is still running
+            if not self.loop.is_closed():
+                pending = asyncio.all_tasks(self.loop)
+                for task in pending:
+                    task.cancel()
+
+                # Only try to gather if loop isn't stopped
+                if self.loop.is_running():
+                    pass  # Can't do much if loop is still running
+                elif pending:
+                    try:
+                        self.loop.run_until_complete(
+                            asyncio.gather(*pending, return_exceptions=True)
+                        )
+                    except RuntimeError:
+                        pass  # Loop already stopped
+
+                self.loop.close()
+        except Exception:
+            pass  # Ignore cleanup errors
+
+    async def _async_run(self):
+        """Async entry point - runs coder loop."""
+        while self.running:
+            try:
+                await self.coder.run()
+                break  # Normal exit
+            except asyncio.CancelledError:
+                break
+            except SwitchCoderSignal as switch:
+                # Handle chat mode switches (e.g., /chat-mode architect)
+                try:
+                    kwargs = dict(io=self.coder.io, from_coder=self.coder)
+                    kwargs.update(switch.kwargs)
+                    if "show_announcements" in kwargs:
+                        del kwargs["show_announcements"]
+                    kwargs["num_cache_warming_pings"] = 0
+                    kwargs["args"] = self.coder.args
+                    # Skip summarization to avoid blocking LLM calls during mode switch
+                    kwargs["summarize_from_coder"] = False
+
+                    new_coder = await Coder.create(**kwargs)
+                    new_coder.args = self.coder.args
+
+                    if switch.kwargs.get("show_announcements") is False:
+                        new_coder.suppress_announcements_for_next_prompt = True
+
+                    # Notify TUI of mode change
+                    self.coder = new_coder
+                    edit_format = getattr(self.coder, "edit_format", "code") or "code"
+                    self.output_queue.put(
+                        {
+                            "type": "mode_change",
+                            "mode": edit_format,
+                        }
+                    )
+                except Exception as e:
+                    self.output_queue.put(
+                        {"type": "error", "message": f"Failed to switch mode: {e}"}
+                    )
+                    break
+                # Continue the loop with the new coder
+            except Exception as e:
+                self.output_queue.put({"type": "error", "message": str(e)})
+                break
+
+    def interrupt(self):
+        """Cancel the current output task on the coder instance."""
+        if self.coder and hasattr(self.coder, "io") and self.coder.io:
+            # Cancel the output task if it exists
+            if hasattr(self.coder.io, "output_task") and self.coder.io.output_task:
+                self.coder.io.output_task.cancel()
+                # Also set output_running to False to stop the output_task loop
+                if hasattr(self.coder, "output_running"):
+                    self.coder.output_running = False
+
+    def stop(self):
+        """Stop the worker thread gracefully."""
+        self.running = False
+
+        # Signal the coder to stop
+        if hasattr(self.coder, "input_running"):
+            self.coder.input_running = False
+        if hasattr(self.coder, "output_running"):
+            self.coder.output_running = False
+
+        if self.loop and self.loop.is_running():
+            try:
+                self.loop.call_soon_threadsafe(self.loop.stop)
+            except RuntimeError:
+                # Loop may already be closed
+                pass
+
+        # Wait for thread to finish
+        if self.thread and self.thread.is_alive():
+            self.thread.join(timeout=2.0)

cecli/urls.py

@@ -0,0 +1,16 @@
+website = "https://cecli.dev/"
+add_all_files = "https://cecli.dev/docs/faq.html#how-can-i-add-all-the-files-to-the-chat"
+edit_errors = "https://cecli.dev/docs/troubleshooting/edit-errors.html"
+git = "https://cecli.dev/docs/git.html"
+enable_playwright = "https://cecli.dev/docs/install/optional.html#enable-playwright"
+favicon = "https://cecli.dev/assets/icons/favicon-32x32.png"
+model_warnings = "https://cecli.dev/docs/llms/warnings.html"
+token_limits = "https://cecli.dev/docs/troubleshooting/token-limits.html"
+llms = "https://cecli.dev/docs/llms.html"
+large_repos = "https://cecli.dev/docs/faq.html#can-i-use-cecli-in-a-large-mono-repo"
+github_issues = "https://github.com/dwash96/aider-ce/issues/new"
+git_index_version = "https://github.com/Aider-AI/aider/issues/211"
+install_properly = "https://cecli.dev/docs/troubleshooting/imports.html"
+release_notes = "https://github.com/dwash96/aider-ce/releases/latest"
+edit_formats = "https://cecli.dev/docs/more/edit-formats.html"
+models_and_keys = "https://cecli.dev/docs/troubleshooting/models-and-keys.html"