vibecore 0.2.0a1__py3-none-any.whl

vibecore/widgets/core.py

@@ -0,0 +1,332 @@
+import os
+import time
+from typing import ClassVar
+
+from textual import events
+from textual.app import ComposeResult
+from textual.containers import Horizontal, ScrollableContainer, Vertical
+from textual.geometry import Size
+from textual.message import Message
+from textual.widget import Widget
+from textual.widgets import Footer, ProgressBar, Static, TextArea
+
+
+class InputBox(Widget):
+    """A simple input box widget."""
+
+    def compose(self) -> ComposeResult:
+        """Create child widgets for the input box."""
+        text_area = MyTextArea(compact=True, id="input-textarea")
+        yield Static(">", id="input-label")
+        yield text_area
+
+
+class AppFooter(Widget):
+    def get_current_working_directory(self) -> str:
+        """Get the current working directory for display.
+
+        Returns:
+            The current working directory path, with home directory replaced by ~
+        """
+        cwd = os.getcwd()
+        if cwd.startswith(os.path.expanduser("~")):
+            cwd = cwd.replace(os.path.expanduser("~"), "~", 1)
+        return cwd
+
+    def compose(self) -> ComposeResult:
+        yield LoadingWidget(status="Generating…", id="loading-widget")
+        yield InputBox()
+        # Wrap ProgressBar in vertical container to dock it right
+        with Vertical(id="context-info"):
+            cwd = self.get_current_working_directory()
+            yield Static(f"{cwd}", id="context-cwd")
+            with Horizontal(id="context-progress-container"):
+                yield Static("Context: ", id="context-progress-label")
+                yield ProgressBar(total=100, id="context-progress", show_eta=False)
+        yield Footer()
+
+    def set_context_progress(self, percent: float) -> None:
+        bar = self.query_one("#context-progress", ProgressBar)
+        value = max(0, min(100, int(percent * 100)))
+        bar.update(total=100, progress=value)
+
+    def on_mount(self) -> None:
+        """Hide loading widget on mount."""
+        self.query_one("#loading-widget").display = False
+
+    def show_loading(self, status: str = "Generating…", metadata: str = "") -> None:
+        """Show the loading widget with given status and metadata."""
+        loading = self.query_one("#loading-widget", LoadingWidget)
+        loading._start_time = time.monotonic()  # Reset the timer
+        loading.update_status(status)
+        if metadata:
+            loading.update_metadata(metadata)
+        loading.display = True
+
+    def hide_loading(self) -> None:
+        """Hide the loading widget."""
+        self.query_one("#loading-widget").display = False
+
+
+class MyTextArea(TextArea):
+    class UserMessage(Message):
+        """A user message input."""
+
+        def __init__(self, text: str) -> None:
+            self.text = text
+            super().__init__()
+
+        def __repr__(self) -> str:
+            return f"UserMessage(text={self.text!r})"
+
+    def __init__(self, **kwargs) -> None:
+        """Initialize MyTextArea with history tracking."""
+        super().__init__(**kwargs)
+        self.history_index = -1  # -1 means we're typing a new message
+        self.draft_text = ""  # Store the draft when navigating history
+
+    async def get_user_history(self) -> list[str]:
+        """Get the list of user messages from the session and current input_items."""
+        from vibecore.main import VibecoreApp
+
+        app = self.app
+        if isinstance(app, VibecoreApp):
+            history = []
+
+            # First, load history from the session
+            if app.session:
+                try:
+                    # Get all items from the session
+                    session_items = await app.session.get_items()
+                    for item in session_items:
+                        # Filter for user messages
+                        if isinstance(item, dict):
+                            # Check both "role" and "type" fields for compatibility
+                            role = item.get("role") or item.get("type")
+                            if role == "user":
+                                content = item.get("content")
+                                if isinstance(content, str):
+                                    history.append(content)
+                except Exception as e:
+                    # Log error but don't crash
+                    from textual import log
+
+                    log(f"Error loading session history: {e}")
+
+            # Then add current session's messages (in memory, not yet persisted)
+            for item in app.input_items:
+                if isinstance(item, dict) and item.get("role") == "user":
+                    content = item.get("content")
+                    if isinstance(content, str) and content not in history:
+                        history.append(content)
+
+            return history
+        return []
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
+        """Check if an action may run."""
+        # If text is empty, allow app to handle ctrl+d, not as delete_right
+        return not (action == "delete_right" and not self.text)
+
+    async def _on_key(self, event: events.Key) -> None:
+        if event.key == "enter":
+            self.post_message(self.UserMessage(self.text))
+            self.text = ""
+            self.history_index = -1  # Reset history navigation
+            self.draft_text = ""
+            event.prevent_default()
+            return
+
+        # Handle up arrow for history navigation
+        if event.key == "up":
+            if not self.cursor_at_start_of_text:
+                # Move cursor to start of text first
+                await super()._on_key(event)
+                return
+            else:
+                # Navigate to previous history item
+                history = await self.get_user_history()
+                if history:
+                    # Save current draft if starting history navigation
+                    if self.history_index == -1:
+                        self.draft_text = self.text
+
+                    # Move to previous item
+                    if self.history_index < len(history) - 1:
+                        self.history_index += 1
+                        self.text = history[-(self.history_index + 1)]
+                        self.move_cursor((0, 0))  # Move cursor to start
+                        event.prevent_default()
+                        return
+
+        # Handle down arrow for history navigation
+        elif event.key == "down":
+            if not self.cursor_at_end_of_text:
+                # Move cursor to end of text first
+                await super()._on_key(event)
+                return
+            else:
+                # Navigate to next history item
+                if self.history_index >= 0:
+                    self.history_index -= 1
+                    if self.history_index == -1:
+                        # Return to draft
+                        self.text = self.draft_text
+                    else:
+                        history = await self.get_user_history()
+                        self.text = history[-(self.history_index + 1)]
+                    # Move cursor to end of text
+                    last_line = self.document.line_count - 1
+                    last_column = len(self.document[last_line]) if last_line >= 0 else 0
+                    self.move_cursor((last_line, last_column))
+                    event.prevent_default()
+                    return
+
+        self._restart_blink()
+
+        if self.read_only:
+            return
+
+        key = event.key
+        insert_values = {
+            "shift+enter": "\n",
+            # Ghostty with config: keybind = shift+enter=text:\n
+            "ctrl+j": "\n",
+        }
+        if self.tab_behavior == "indent":
+            if key == "escape":
+                event.stop()
+                event.prevent_default()
+                self.screen.focus_next()
+                return
+            if self.indent_type == "tabs":
+                insert_values["tab"] = "\t"
+            else:
+                insert_values["tab"] = " " * self._find_columns_to_next_tab_stop()
+
+        if event.is_printable or key in insert_values:
+            event.stop()
+            event.prevent_default()
+            insert = insert_values.get(key, event.character)
+            # `insert` is not None because event.character cannot be
+            # None because we've checked that it's printable.
+            assert insert is not None
+            start, end = self.selection
+            self._replace_via_keyboard(insert, start, end)
+
+
+class MainScroll(ScrollableContainer):
+    """A container with vertical layout and an automatic scrollbar on the Y axis."""
+
+    def watch_virtual_size(self, size: Size) -> None:
+        """Scroll to the bottom when resized = when new content is added."""
+        # If the scroll is near the end, keep the scroll sticky to the end
+        epsilon = 30
+        in_the_end = (size.height - (self.scroll_target_y + self.scrollable_size.height)) < epsilon
+        if size.height > self.scrollable_size.height and in_the_end:
+            self.scroll_end(animate=False)
+
+
+class LoadingWidget(Widget):
+    """A loading indicator with spinner, status text, and metadata."""
+
+    DEFAULT_CSS = """
+    LoadingWidget {
+        width: 1fr;
+        height: 1;
+        padding: 0 1;
+    }
+
+    LoadingWidget .loading-spinner {
+        color: $primary;
+    }
+
+    LoadingWidget .loading-status {
+        color: $text;
+        margin: 0 1;
+    }
+
+    LoadingWidget .loading-metadata {
+        color: $text-muted;
+    }
+    """
+
+    SPINNERS: ClassVar[list[str]] = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+    def __init__(
+        self,
+        status: str = "Loading…",
+        show_time: bool = True,
+        show_metadata: bool = True,
+        metadata: str = "",
+        escape_message: str = "esc to interrupt",
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.status = status
+        self.show_time = show_time
+        self.show_metadata = show_metadata
+        self.metadata = metadata
+        self.escape_message = escape_message
+        self._spinner_index = 0
+        self._start_time = time.monotonic()
+        self._spinner_timer = None
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="loading-content")
+
+    def on_mount(self) -> None:
+        """Start the spinner animation when mounted."""
+        self._spinner_timer = self.set_interval(0.1, self._update_spinner)
+        self._update_display()
+
+    def on_unmount(self) -> None:
+        """Stop the spinner animation when unmounted."""
+        if self._spinner_timer:
+            self._spinner_timer.stop()
+
+    def _update_spinner(self) -> None:
+        """Update the spinner character and elapsed time."""
+        self._spinner_index = (self._spinner_index + 1) % len(self.SPINNERS)
+        self._update_display()
+
+    def _update_display(self) -> None:
+        """Update the entire loading display."""
+        parts = []
+
+        # Spinner
+        spinner = self.SPINNERS[self._spinner_index]
+        parts.append(f"[bold]{spinner}[/bold]")
+
+        # Status text
+        parts.append(self.status)
+
+        # Metadata section
+        metadata_parts = []
+
+        if self.show_time:
+            elapsed = int(time.monotonic() - self._start_time)
+            metadata_parts.append(f"{elapsed}s")
+
+        if self.show_metadata and self.metadata:
+            metadata_parts.append(self.metadata)
+
+        if self.escape_message:
+            metadata_parts.append(self.escape_message)
+
+        if metadata_parts:
+            metadata_str = " · ".join(metadata_parts)
+            parts.append(f"[dim]({metadata_str})[/dim]")
+
+        content = " ".join(parts)
+        self.query_one("#loading-content", Static).update(content)
+
+    def update_status(self, status: str) -> None:
+        """Update the status text."""
+        self.status = status
+        self._update_display()
+
+    def update_metadata(self, metadata: str) -> None:
+        """Update the metadata text."""
+        self.metadata = metadata
+        self._update_display()

vibecore/widgets/core.tcss

@@ -0,0 +1,63 @@
+AppFooter {
+    dock: bottom;
+    height: auto;
+}
+
+Footer {
+    dock: none;
+}
+
+#context-info {
+    height: 2;
+    color: $text-primary;
+
+    #context-cwd {
+        margin-left: 1;
+        height: 1;
+        width: auto;
+        dock: left;
+    }
+
+    #context-progress-container {
+        margin-right: 1;
+        height: auto;
+        width: auto;
+        dock: right;
+        layout: horizontal;
+
+        #context-progress-label {
+            width: auto;
+        }
+    }
+}
+
+InputBox {
+    height: auto;
+    layout: horizontal;
+
+    #input-label {
+        width: 3;
+        height: 1;
+        text-align: center;
+    }
+
+    TextArea {
+        width: 1fr;
+        height: auto;
+        max-height: 10;
+        min-height: 1;
+        border: none;
+        padding: 0 0;
+        background: $background;
+        & .text-area--cursor-line {
+            background: $background;
+        }
+    }
+
+    border: round $border-blurred;
+    &:focus-within {
+        border: round $border;
+    }
+
+    # background: $surface;
+}

vibecore/widgets/expandable.py

@@ -0,0 +1,121 @@
+"""Expandable content widgets for Textual applications."""
+
+from textual.app import ComposeResult
+from textual.content import Content
+from textual.events import Click
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Markdown, Static
+
+
+class ExpandableContent(Widget):
+    """A widget that shows truncated content with an expandable button."""
+
+    expanded: reactive[bool] = reactive(False, recompose=True)
+
+    def __init__(
+        self, content: str | Content, truncated_lines: int = 3, collapsed_text: str | Content | None = None, **kwargs
+    ) -> None:
+        """
+        Initialize the ExpandableContent widget.
+
+        Args:
+            content: The full content to display (str or Content for safe rendering)
+            truncated_lines: Number of lines to show when collapsed (ignored if collapsed_text is provided)
+            collapsed_text: Custom text to show when collapsed (overrides truncated content)
+            **kwargs: Additional keyword arguments for Widget
+        """
+        super().__init__(**kwargs)
+        self.content = content
+        self.truncated_lines = truncated_lines
+        self.collapsed_text = collapsed_text
+        # Extract plain text for line counting
+        self.content_str = str(content) if isinstance(content, Content) else content
+        self.lines = self.content_str.splitlines()
+        self.total_lines = len(self.lines)
+
+    def compose(self) -> ComposeResult:
+        """Create child widgets based on expanded state."""
+        if self.expanded:
+            # Show all content
+            yield Static(self.content, classes="expandable-content-full")
+            yield Static("▲ collapse", classes="expandable-toggle expanded")
+        else:
+            # Show custom collapsed text if provided
+            if self.collapsed_text is not None:
+                yield Static(self.collapsed_text, classes="expandable-toggle collapsed")
+            # Show truncated content
+            elif self.total_lines > self.truncated_lines:
+                truncated_text = "\n".join(self.lines[: self.truncated_lines])
+                # Preserve Content safety if original was Content
+                truncated_content = Content(truncated_text) if isinstance(self.content, Content) else truncated_text
+                yield Static(truncated_content, classes="expandable-content-truncated")
+                remaining_lines = self.total_lines - self.truncated_lines
+                yield Static(f"… +{remaining_lines} more lines (view)", classes="expandable-toggle collapsed")
+            else:
+                # If content fits, just show it all
+                yield Static(self.content, classes="expandable-content-full")
+
+    def on_click(self, event: Click) -> None:
+        """Handle click events to toggle expansion."""
+        # Only toggle if we clicked on the toggle element
+        if event.widget and event.widget.has_class("expandable-toggle"):
+            self.expanded = not self.expanded
+            event.stop()
+
+
+class ExpandableMarkdown(Widget):
+    """A widget that shows truncated Markdown content with an expandable button."""
+
+    expanded: reactive[bool] = reactive(False, recompose=True)
+
+    def __init__(self, code: str, language: str = "python", truncated_lines: int = 8, **kwargs) -> None:
+        """
+        Initialize the ExpandableMarkdown widget.
+
+        Args:
+            code: The full code to display
+            language: Programming language for syntax highlighting (empty string for plain markdown)
+            truncated_lines: Number of lines to show when collapsed
+            **kwargs: Additional keyword arguments for Widget
+        """
+        super().__init__(**kwargs)
+        self.code = code
+        self.language = language
+        self.truncated_lines = truncated_lines
+        self.lines = code.splitlines()
+        self.total_lines = len(self.lines)
+
+    def compose(self) -> ComposeResult:
+        """Create child widgets based on expanded state."""
+        # Determine content format based on language
+        if self.language:
+            # Render as code block with syntax highlighting
+            full_content = f"```{self.language}\n{self.code}\n```"
+            truncated_lines = "\n".join(self.lines[: self.truncated_lines])
+            truncated_content = f"```{self.language}\n{truncated_lines}\n```"
+        else:
+            # Render as plain markdown (no code block)
+            full_content = self.code
+            truncated_content = "\n".join(self.lines[: self.truncated_lines])
+
+        if self.expanded:
+            # Show all content
+            yield Markdown(full_content, classes="expandable-markdown-full")
+            yield Static("▲ collapse", classes="expandable-toggle expanded")
+        else:
+            # Show truncated content
+            if self.total_lines > self.truncated_lines:
+                yield Markdown(truncated_content, classes="expandable-markdown-truncated")
+                remaining_lines = self.total_lines - self.truncated_lines
+                yield Static(f"… +{remaining_lines} more lines (view)", classes="expandable-toggle collapsed")
+            else:
+                # If content fits, just show it all
+                yield Markdown(full_content, classes="expandable-markdown-full")
+
+    def on_click(self, event: Click) -> None:
+        """Handle click events to toggle expansion."""
+        # Only toggle if we clicked on the toggle element
+        if event.widget and event.widget.has_class("expandable-toggle"):
+            self.expanded = not self.expanded
+            event.stop()

vibecore/widgets/expandable.tcss

@@ -0,0 +1,69 @@
+/* Expandable Content Widget Styles */
+ExpandableContent {
+    height: auto;
+    
+    .expandable-content-truncated, .expandable-content-full {
+        padding: 0;
+        margin: 0;
+        height: auto;
+    }
+    
+    .expandable-toggle {
+        padding: 0 0 0 0;
+        margin: 0 0 0 0;
+        width: auto;
+        
+        &:hover {
+            color: $primary;
+        }
+        
+        &.collapsed {
+            margin-top: 0;
+        }
+        
+        &.expanded {
+            margin-top: 1;
+        }
+    }
+}
+
+/* Expandable Markdown Widget Styles */
+ExpandableMarkdown {
+    height: auto;
+    width: 1fr;
+    
+    Markdown {
+        background: $background;
+        padding: 0;
+        
+        MarkdownFence {
+            margin: 0;
+            padding: 0;
+            max-height: 100%;
+
+            &> Static {
+                # Override MarkdownFence > Static (Syntax) padding/margin
+                width: 1fr;  # Trigger word-wrap instead of overflow
+                padding: 0 2 0 0;
+            }
+        }
+    }
+    
+    .expandable-toggle {
+        padding: 0 0 0 2;
+        margin: 0 0 0 0;
+        width: auto;
+        
+        &:hover {
+            color: $primary;
+        }
+        
+        &.collapsed {
+            margin-top: 0;
+        }
+        
+        &.expanded {
+            margin-top: 1;
+        }
+    }
+}

vibecore/widgets/info.py

@@ -0,0 +1,25 @@
+from textual.app import ComposeResult
+from textual.widget import Widget
+from textual.widgets import Static
+
+VIBECORE_LOGO = """
+██╗   ██╗██╗██████╗ ███████╗ ██████╗ ██████╗ ██████╗ ███████╗
+██║   ██║██║██╔══██╗██╔════╝██╔════╝██╔═══██╗██╔══██╗██╔════╝
+██║   ██║██║██████╔╝█████╗  ██║     ██║   ██║██████╔╝█████╗
+╚██╗ ██╔╝██║██╔══██╗██╔══╝  ██║     ██║   ██║██╔══██╗██╔══╝
+ ╚████╔╝ ██║██████╔╝███████╗╚██████╗╚██████╔╝██║  ██║███████╗
+  ╚═══╝  ╚═╝╚═════╝ ╚══════╝ ╚═════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝
+""".strip()
+
+
+class Welcome(Widget):
+    """A simple input box widget."""
+
+    def compose(self) -> ComposeResult:
+        """Create child widgets for the input box."""
+        yield Static(f"[$primary]{VIBECORE_LOGO}[/]", classes="logo")
+        yield Static("Welcome to [$text-primary][b]Vibecore[/b][/]!", classes="title")
+        yield Static(
+            "Type '/help' to see available commands.",
+            classes="subtitle",
+        )

vibecore/widgets/info.tcss

@@ -0,0 +1,17 @@
+
+Welcome {
+    height: auto;
+    width: auto;
+    padding: 1 2;
+    margin-bottom: 1;
+
+    border: round $border;
+
+    .logo {
+        margin-bottom: 1;
+    }
+
+    Static {
+        width: auto;
+    }
+}