connectonion 0.5.8__py3-none-any.whl

connectonion/tui/footer.py

@@ -0,0 +1,31 @@
+"""
+Footer - Simple tips display.
+
+Usage:
+    from connectonion.tui import Footer
+
+    footer = Footer(["? help", "/ commands", "@ contacts"])
+    console.print(footer.render())
+"""
+
+from rich.text import Text
+
+
+class Footer:
+    """Simple footer - displays what you give it."""
+
+    def __init__(self, tips: list[str]):
+        """
+        Args:
+            tips: List of tips to display
+        """
+        self.tips = tips
+
+    def render(self) -> Text:
+        """Render tips."""
+        out = Text()
+        for i, tip in enumerate(self.tips):
+            out.append(tip, style="dim")
+            if i < len(self.tips) - 1:
+                out.append("  ", style="dim")
+        return out

connectonion/tui/fuzzy.py

@@ -0,0 +1,56 @@
+"""Fuzzy matching utilities."""
+
+from rich.text import Text
+
+
+def fuzzy_match(query: str, text: str) -> tuple[bool, int, list[int]]:
+    """Fuzzy match query against text.
+
+    Args:
+        query: Search query
+        text: Text to match against
+
+    Returns:
+        (matched, score, positions) - Higher score = better match
+    """
+    if not query:
+        return True, 0, []
+
+    query = query.lower()
+    text_lower = text.lower()
+
+    positions = []
+    query_idx = 0
+    last_match = -1
+    score = 0
+
+    for i, char in enumerate(text_lower):
+        if query_idx < len(query) and char == query[query_idx]:
+            positions.append(i)
+            # Consecutive match bonus
+            if last_match == i - 1:
+                score += 10
+            # Word boundary bonus
+            if i == 0 or text[i-1] in '/_-. ':
+                score += 5
+            score += 1
+            last_match = i
+            query_idx += 1
+
+    matched = query_idx == len(query)
+    return matched, score if matched else 0, positions
+
+
+def highlight_match(text: str, positions: list[int]) -> Text:
+    """Highlight matched characters in Rich Text.
+
+    Uses green for matched chars (ConnectOnion theme).
+    """
+    result = Text()
+    pos_set = set(positions)
+    for i, char in enumerate(text):
+        if i in pos_set:
+            result.append(char, style="bold magenta")  # Violet for matched chars
+        else:
+            result.append(char)
+    return result

connectonion/tui/input.py

@@ -0,0 +1,278 @@
+"""Input - smart input component with triggers and autocomplete.
+
+Clean, minimal design that works on light and dark terminals.
+Inspired by powerlevel10k terminal prompts.
+"""
+
+import random
+from typing import Optional
+from rich.console import Console, Group
+from rich.text import Text
+from rich.live import Live
+
+from .keys import read_key
+from .dropdown import Dropdown
+from .providers import FileProvider
+
+
+# Color palette - works on both light and dark terminals
+COLORS = {
+    "prompt": "bold magenta",
+    "text": "default",  # User input in default terminal color
+    "filter": "bold green",
+    "cursor": "reverse",
+    "hint": "dim",
+    "tip": "dim italic",
+}
+
+# Global counter for rotating tips
+_input_count = 0
+
+
+class Input:
+    """Smart input with trigger-based autocomplete.
+
+    Usage:
+        from connectonion.tui import Input, FileProvider
+
+        # Simple
+        text = Input().run()
+
+        # With autocomplete
+        text = Input(triggers={"@": FileProvider()}).run()
+
+        # With hints (always visible) and tips (rotating)
+        text = Input(
+            hints=["/ commands", "@ contacts", "Enter submit"],
+            tips=["Try /today for briefing", "Join our Discord!"],
+            divider=True,
+        ).run()
+    """
+
+    def __init__(
+        self,
+        prompt: str = None,
+        triggers: dict = None,
+        hints: list[str] = None,
+        tips: list[str] = None,
+        divider: bool = False,
+        max_visible: int = 8,
+        console: Console = None,
+        style: str = "modern",
+    ):
+        """
+        Args:
+            prompt: Custom prompt text
+            triggers: Dict of {char: Provider} for autocomplete
+            hints: Always-visible keyboard hints (e.g., ["/ commands", "Enter submit"])
+            tips: Rotating tips shown occasionally (e.g., ["Try /today", "Join Discord"])
+            divider: Add horizontal dividers around input
+            max_visible: Max dropdown items
+            console: Rich console
+            style: "modern", "minimal", or "classic"
+        """
+        self.prompt = prompt
+        self.triggers = triggers or {}
+        self.hints = hints
+        self.tips = tips
+        self.divider = divider
+        self.max_visible = max_visible
+        self.console = console or Console()
+        self.style = style
+
+        # State
+        self.buffer = ""
+        self.active_trigger = None
+        self.filter_text = ""
+        self.dropdown = Dropdown(max_visible=max_visible)
+
+    def _render_prompt(self) -> Text:
+        """Render prompt based on style."""
+        if self.prompt:
+            return Text(self.prompt)
+
+        prompts = {"modern": "❯ ", "minimal": "> ", "classic": "$ "}
+        return Text(prompts.get(self.style, "❯ "), style=COLORS["prompt"])
+
+    def _get_rotating_tip(self) -> str | None:
+        """Get a rotating tip (shows every 4 inputs, 60% chance)."""
+        global _input_count
+        if not self.tips:
+            return None
+        # Show tip every 4 rounds with 60% probability
+        if _input_count % 4 == 0 and random.random() < 0.6:
+            return self.tips[(_input_count // 4) % len(self.tips)]
+        return None
+
+    def _render(self) -> Group:
+        """Render the input UI."""
+        parts = []
+
+        # Top divider (very dim solid line, full width)
+        if self.divider:
+            width = self.console.width or 80
+            parts.append(Text("─" * width, style="dim bright_black"))
+
+        # Input line: prompt + buffer + filter + cursor
+        line = self._render_prompt()
+        if self.buffer:
+            line.append(self.buffer)  # Default terminal color
+        if self.active_trigger:
+            line.append(self.filter_text, style=COLORS["filter"])
+        line.append(" ", style=COLORS["cursor"])
+        parts.append(line)
+
+        # Dropdown
+        if self.active_trigger and not self.dropdown.is_empty:
+            parts.append(Text())
+            parts.append(self.dropdown.render())
+
+        # Bottom divider (very dim solid line, full width)
+        if self.divider:
+            width = self.console.width or 80
+            parts.append(Text("─" * width, style="dim bright_black"))
+
+        # Hints (always visible, under divider)
+        if self.hints:
+            hint_line = Text()
+            for i, hint in enumerate(self.hints):
+                hint_line.append(hint, style=COLORS["hint"])
+                if i < len(self.hints) - 1:
+                    hint_line.append("  ")
+            parts.append(hint_line)
+
+        # Rotating tip (occasional, under hints)
+        tip = self._get_rotating_tip()
+        if tip:
+            parts.append(Text(tip, style=COLORS["tip"]))
+
+        return Group(*parts)
+
+    def _accept_selection(self) -> bool:
+        """Accept dropdown selection. Returns True if navigating directory."""
+        value = self.dropdown.selected_value
+        if value is None:
+            return False
+
+        # Directory navigation for FileProvider
+        if isinstance(value, str) and value.endswith('/'):
+            provider = self.triggers.get(self.active_trigger)
+            if isinstance(provider, FileProvider):
+                provider.enter(value)
+                self.filter_text = ""
+                self._update_dropdown()
+                return True
+
+        # Accept selection
+        if self.active_trigger and self.buffer.endswith(self.active_trigger):
+            self.buffer = self.buffer[:-len(self.active_trigger)]
+        self.buffer += str(value)
+        self._exit_autocomplete()
+        return False
+
+    def _update_dropdown(self):
+        """Update dropdown from provider."""
+        provider = self.triggers.get(self.active_trigger)
+        if provider:
+            self.dropdown.set_items(provider.search(self.filter_text))
+        else:
+            self.dropdown.clear()
+
+    def _exit_autocomplete(self):
+        """Exit autocomplete mode."""
+        self.active_trigger = None
+        self.filter_text = ""
+        self.dropdown.clear()
+        for provider in self.triggers.values():
+            if isinstance(provider, FileProvider):
+                provider.context = ""
+
+    def run(self) -> str:
+        """Run input loop. Returns entered text."""
+        global _input_count
+        _input_count += 1
+
+        with Live(self._render(), console=self.console, auto_refresh=False) as live:
+            while True:
+                key = read_key()
+
+                # Enter - submit or accept selection
+                if key in ('\r', '\n'):
+                    if self.active_trigger:
+                        if not self.dropdown.is_empty:
+                            if self._accept_selection():
+                                live.update(self._render(), refresh=True)
+                                continue
+                            live.update(self._render(), refresh=True)
+                        else:
+                            self._exit_autocomplete()
+                            live.update(self._render(), refresh=True)
+                    else:
+                        return self.buffer
+
+                # Tab - accept selection
+                elif key == '\t':
+                    if self.active_trigger and not self.dropdown.is_empty:
+                        if self._accept_selection():
+                            live.update(self._render(), refresh=True)
+                            continue
+                        live.update(self._render(), refresh=True)
+
+                # Escape - cancel autocomplete
+                elif key == 'esc':
+                    if self.active_trigger:
+                        if self.buffer.endswith(self.active_trigger):
+                            self.buffer = self.buffer[:-1]
+                        self._exit_autocomplete()
+                        live.update(self._render(), refresh=True)
+
+                # Ctrl+C / Ctrl+D
+                elif key == '\x03':
+                    raise KeyboardInterrupt()
+                elif key == '\x04':
+                    raise EOFError()
+
+                # Backspace
+                elif key in ('\x7f', '\x08'):
+                    if self.active_trigger:
+                        if self.filter_text:
+                            self.filter_text = self.filter_text[:-1]
+                            self._update_dropdown()
+                        else:
+                            provider = self.triggers.get(self.active_trigger)
+                            if isinstance(provider, FileProvider) and provider.context:
+                                provider.back()
+                                self._update_dropdown()
+                            else:
+                                if self.buffer.endswith(self.active_trigger):
+                                    self.buffer = self.buffer[:-1]
+                                self._exit_autocomplete()
+                        live.update(self._render(), refresh=True)
+                    elif self.buffer:
+                        self.buffer = self.buffer[:-1]
+                        live.update(self._render(), refresh=True)
+
+                # Arrow keys
+                elif key == 'up' and self.active_trigger:
+                    self.dropdown.up()
+                    live.update(self._render(), refresh=True)
+                elif key == 'down' and self.active_trigger:
+                    self.dropdown.down()
+                    live.update(self._render(), refresh=True)
+
+                # Trigger char
+                elif key in self.triggers:
+                    self.active_trigger = key
+                    self.filter_text = ""
+                    self.buffer += key
+                    self._update_dropdown()
+                    live.update(self._render(), refresh=True)
+
+                # Regular input
+                elif key.isprintable():
+                    if self.active_trigger:
+                        self.filter_text += key
+                        self._update_dropdown()
+                    else:
+                        self.buffer += key
+                    live.update(self._render(), refresh=True)

connectonion/tui/keys.py

@@ -0,0 +1,35 @@
+"""Low-level keyboard input primitives."""
+
+import sys
+
+
+def getch() -> str:
+    """Read single character without waiting for Enter."""
+    try:
+        import termios
+        import tty
+        fd = sys.stdin.fileno()
+        old = termios.tcgetattr(fd)
+        tty.setraw(fd)
+        ch = sys.stdin.read(1)
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+        return ch
+    except ImportError:
+        import msvcrt
+        return msvcrt.getch().decode('utf-8', errors='ignore')
+
+
+def read_key() -> str:
+    """Read key with arrow/escape sequence handling.
+
+    Returns:
+        Single char, or 'up'/'down'/'left'/'right' for arrows, 'esc' for escape
+    """
+    ch = getch()
+    if ch == '\x1b':
+        ch2 = getch()
+        if ch2 == '[':
+            ch3 = getch()
+            return {'A': 'up', 'B': 'down', 'C': 'right', 'D': 'left'}.get(ch3, 'esc')
+        return 'esc'
+    return ch

connectonion/tui/pick.py

@@ -0,0 +1,130 @@
+"""
+Purpose: Single-select menu component with keyboard navigation for terminal-based option selection
+LLM-Note:
+  Dependencies: imports from [sys, rich.console, rich.live, rich.text, .keys] | imported by [tui/__init__.py, useful_tools/__init__.py] | used in CLI menus and agent tool confirmations
+  Data flow: caller invokes pick(title, options, other) → renders menu with Rich Live → reads keyboard via read_key() → up/down arrows move selection → Enter confirms → returns selected label string | if other=True and "Other..." selected, prompts for custom text input
+  State/Effects: uses Rich Live for in-place rendering | manages cursor position state | reads raw keyboard input | no file I/O
+  Integration: exposes pick(title, options, other, console) → str | options can be strings or (label, description) tuples | optional "Other..." for custom input | returns selected label or custom text
+  Performance: O(n) options rendering | single keystroke per action | real-time re-render on selection change
+  Errors: KeyboardInterrupt returns None or empty string | terminal restored on exit
+
+Usage:
+    from connectonion.tui import pick
+
+    # Simple list selection
+    choice = pick("Pick a color", ["Red", "Green", "Blue"])
+
+    # With descriptions
+    choice = pick("Send email?", [
+        ("Yes, send it", "Send immediately"),
+        ("Auto approve", "Skip for this recipient"),
+    ])
+
+    # With "Other" option for custom input
+    choice = pick("Continue?", ["Yes", "No"], other=True)
+"""
+
+import sys
+from rich.console import Console
+from rich.live import Live
+from rich.text import Text
+from .keys import read_key
+
+
+def pick(title: str, options: list, other: bool = False, console: Console = None) -> str:
+    """Single-select menu with keyboard navigation.
+
+    Args:
+        title: Question to display
+        options: List of strings or (label, description) tuples
+        other: Add "Other..." option for custom text input
+        console: Optional Rich console
+
+    Returns:
+        Selected option label, or custom text if "Other" chosen
+    """
+    console = console or Console()
+
+    # Normalize options to (label, description) tuples
+    items = []
+    for opt in options:
+        if isinstance(opt, str):
+            items.append((opt, ""))
+        else:
+            items.append((opt[0], opt[1] if len(opt) > 1 else ""))
+    if other:
+        items.append(("Other...", ""))
+
+    selected = 0
+    total = len(items)
+    lines = total + 4  # title + blank + options + blank + footer
+
+    def render() -> Text:
+        out = Text()
+        out.append(f"{title}\n\n", style="bold")
+        for i, (label, desc) in enumerate(items):
+            if i == selected:
+                out.append(f"  ❯ {i+1}  {label}", style="bold cyan")
+            else:
+                out.append(f"    {i+1}  ", style="dim cyan")
+                out.append(label, style="dim")
+            if desc:
+                out.append(f"  {desc}", style="dim")
+            out.append("\n")
+        # Footer with key hints
+        out.append("\n")
+        out.append("↑↓", style="cyan")
+        out.append(" navigate  ", style="dim")
+        out.append("1-9", style="cyan")
+        out.append(" jump  ", style="dim")
+        out.append("Enter", style="cyan")
+        out.append(" select", style="dim")
+        return out
+
+    def show_result(text: str):
+        sys.stdout.write(f"\033[{lines}A\033[J")  # Clear menu
+        result = Text()
+        result.append(f"{title} ", style="bold")
+        result.append("✓ ", style="green")
+        result.append(text, style="dim")
+        console.print(result)
+
+    def get_other_input() -> str:
+        sys.stdout.write(f"\033[{lines}A\033[J")  # Clear menu
+        console.print(f"[bold]{title}[/]")
+        return input("  → ")
+
+    def handle_select(idx: int) -> str:
+        if other and idx == total - 1:
+            return get_other_input()
+        label = items[idx][0]
+        show_result(label)
+        return label
+
+    # Hide cursor and run
+    print("\033[?25l", end="", flush=True)
+    try:
+        with Live(render(), console=console, auto_refresh=False) as live:
+            while True:
+                key = read_key()
+
+                if key == 'up':
+                    selected = (selected - 1) % total
+                    live.update(render(), refresh=True)
+                elif key == 'down':
+                    selected = (selected + 1) % total
+                    live.update(render(), refresh=True)
+                elif key in ('\r', '\n'):
+                    live.stop()
+                    print("\033[?25h", end="", flush=True)
+                    return handle_select(selected)
+                elif key.isdigit() and 0 < int(key) <= total:
+                    live.stop()
+                    print("\033[?25h", end="", flush=True)
+                    return handle_select(int(key) - 1)
+                elif key == '\x03':
+                    raise KeyboardInterrupt()
+                elif key == '\x04':
+                    raise EOFError()
+    finally:
+        print("\033[?25h", end="", flush=True)

connectonion/tui/providers.py

@@ -0,0 +1,155 @@
+"""Providers for CommandPalette and Input autocomplete."""
+
+from pathlib import Path
+from typing import Protocol, runtime_checkable, Union
+
+from .fuzzy import fuzzy_match
+from .dropdown import DropdownItem
+
+
+@runtime_checkable
+class Provider(Protocol):
+    """Protocol for autocomplete providers."""
+
+    def search(self, query: str) -> list[Union[DropdownItem, tuple]]:
+        """Return matches as DropdownItem or (display, value, score, positions) tuple."""
+        ...
+
+
+class StaticProvider:
+    """Provider for static list of items.
+
+    Supports multiple input formats:
+    - (display, value) - simple tuple
+    - (display, value, description) - with description
+    - (display, value, description, icon) - with icon
+    - DropdownItem - full control
+
+    Usage:
+        # Simple commands
+        provider = StaticProvider([
+            ("/today", "/today"),
+            ("/inbox", "/inbox"),
+        ])
+
+        # With descriptions
+        provider = StaticProvider([
+            ("/today", "/today", "Daily email briefing"),
+            ("/inbox", "/inbox", "Show recent emails"),
+        ])
+
+        # With icons
+        provider = StaticProvider([
+            ("/today", "/today", "Daily briefing", "📅"),
+            ("/inbox", "/inbox", "Show emails", "📥"),
+        ])
+    """
+
+    def __init__(self, items: list):
+        """
+        Args:
+            items: List of tuples or DropdownItem objects
+        """
+        self.items = self._normalize_items(items)
+
+    def _normalize_items(self, items: list) -> list[tuple]:
+        """Convert items to normalized format (display, value, description, icon)."""
+        normalized = []
+        for item in items:
+            if isinstance(item, DropdownItem):
+                normalized.append((item.display, item.value, item.description, item.icon))
+            elif len(item) == 2:
+                normalized.append((item[0], item[1], "", ""))
+            elif len(item) == 3:
+                normalized.append((item[0], item[1], item[2], ""))
+            elif len(item) >= 4:
+                normalized.append((item[0], item[1], item[2], item[3]))
+        return normalized
+
+    def search(self, query: str) -> list[DropdownItem]:
+        results = []
+        for display, value, description, icon in self.items:
+            matched, score, positions = fuzzy_match(query, display)
+            if matched:
+                results.append(DropdownItem(
+                    display=display,
+                    value=value,
+                    score=score,
+                    positions=positions,
+                    description=description,
+                    icon=icon,
+                ))
+        return sorted(results, key=lambda x: -x.score)
+
+
+class FileProvider:
+    """Provider for file system navigation with directory traversal."""
+
+    def __init__(
+        self,
+        root: Path = None,
+        show_hidden: bool = False,
+        dirs_only: bool = False,
+        files_only: bool = False,
+    ):
+        self.root = Path(root) if root else Path(".")
+        self.show_hidden = show_hidden
+        self.dirs_only = dirs_only
+        self.files_only = files_only
+        self._context = ""  # Current directory for nested navigation
+
+    @property
+    def context(self) -> str:
+        return self._context
+
+    @context.setter
+    def context(self, value: str):
+        self._context = value
+
+    def search(self, query: str) -> list[DropdownItem]:
+        """Search files in current context directory."""
+        base = self.root / self._context if self._context else self.root
+        if not base.exists():
+            return []
+
+        results = []
+        for f in base.iterdir():
+            if not self.show_hidden and f.name.startswith('.'):
+                continue
+            if self.dirs_only and not f.is_dir():
+                continue
+            if self.files_only and f.is_dir():
+                continue
+
+            is_dir = f.is_dir()
+            name = f.name + ("/" if is_dir else "")
+            matched, score, positions = fuzzy_match(query, name)
+
+            if matched:
+                full_path = (self._context + name) if self._context else name
+                # Icons are handled by Dropdown based on filename
+                results.append(DropdownItem(
+                    display=name,
+                    value=full_path,
+                    score=score,
+                    positions=positions,
+                ))
+
+        # Sort: directories first, then by score, then alphabetically
+        results.sort(key=lambda x: (not x.display.endswith('/'), -x.score, x.display.lower()))
+        return results
+
+    def enter(self, path: str) -> bool:
+        """Enter a directory. Returns True if successful."""
+        if path.endswith('/'):
+            self._context = path
+            return True
+        return False
+
+    def back(self) -> bool:
+        """Go up one directory. Returns True if moved up."""
+        if self._context:
+            parts = self._context.rstrip('/').rsplit('/', 1)
+            self._context = parts[0] + '/' if len(parts) > 1 else ""
+            return True
+        return False