fast-resume 1.12.8__py3-none-any.whl

fast_resume/tui/filter_bar.py

@@ -0,0 +1,128 @@
+"""Filter bar widget for agent selection."""
+
+from textual.containers import Horizontal
+from textual.events import Click
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widgets import Label
+from textual_image.widget import Image as ImageWidget
+
+from ..config import AGENTS
+from .utils import ASSETS_DIR
+
+# Filter keys in display order (None = "All")
+FILTER_KEYS: list[str | None] = [
+    None,
+    "claude",
+    "codex",
+    "copilot-cli",
+    "copilot-vscode",
+    "crush",
+    "opencode",
+    "vibe",
+]
+
+# Map button IDs to filter values
+_FILTER_ID_MAP: dict[str, str | None] = {
+    f"filter-{key or 'all'}": key for key in FILTER_KEYS
+}
+
+
+class FilterBar(Horizontal):
+    """A horizontal bar of filter buttons for agent selection.
+
+    Emits FilterBar.Changed when filter selection changes.
+    """
+
+    class Changed(Message):
+        """Posted when the active filter changes."""
+
+        def __init__(self, filter_key: str | None) -> None:
+            self.filter_key = filter_key
+            super().__init__()
+
+    active_filter: reactive[str | None] = reactive(None)
+
+    def __init__(
+        self,
+        initial_filter: str | None = None,
+        id: str | None = None,
+    ) -> None:
+        super().__init__(id=id)
+        self._initial_filter = initial_filter
+        self._filter_buttons: dict[str | None, Horizontal] = {}
+
+    def compose(self):
+        """Create filter buttons."""
+        for filter_key in FILTER_KEYS:
+            filter_label = AGENTS[filter_key]["badge"] if filter_key else "All"
+            btn_id = f"filter-{filter_key or 'all'}"
+            with Horizontal(id=btn_id, classes="filter-btn") as btn_container:
+                if filter_key:
+                    icon_path = ASSETS_DIR / f"{filter_key}.png"
+                    if icon_path.exists():
+                        yield ImageWidget(icon_path, classes="filter-icon")
+                    yield Label(
+                        filter_label, classes=f"filter-label agent-{filter_key}"
+                    )
+                else:
+                    yield Label(filter_label, classes="filter-label")
+            self._filter_buttons[filter_key] = btn_container
+
+    def on_mount(self) -> None:
+        """Initialize active filter state."""
+        self.active_filter = self._initial_filter
+        self._update_button_styles()
+
+    def watch_active_filter(self, value: str | None) -> None:
+        """Update button styles when active filter changes."""
+        self._update_button_styles()
+
+    def _update_button_styles(self) -> None:
+        """Update filter button active states."""
+        for filter_key, btn in self._filter_buttons.items():
+            if filter_key == self.active_filter:
+                btn.add_class("-active")
+            else:
+                btn.remove_class("-active")
+
+    def set_active(self, filter_key: str | None, notify: bool = False) -> None:
+        """Set the active filter programmatically.
+
+        Args:
+            filter_key: The filter to activate, or None for "All".
+            notify: If True, emit a Changed message.
+        """
+        if filter_key != self.active_filter:
+            self.active_filter = filter_key
+            if notify:
+                self.post_message(self.Changed(filter_key))
+
+    def on_click(self, event: Click) -> None:
+        """Handle click on filter buttons."""
+        # Walk up to find the filter-btn container (click might be on child widget)
+        widget = event.widget
+        while widget and widget is not self:
+            if hasattr(widget, "classes") and "filter-btn" in widget.classes:
+                if widget.id in _FILTER_ID_MAP:
+                    new_filter = _FILTER_ID_MAP[widget.id]
+                    if new_filter != self.active_filter:
+                        self.active_filter = new_filter
+                        self.post_message(self.Changed(new_filter))
+                return
+            widget = widget.parent
+
+    def update_agents_with_sessions(self, agents: set[str]) -> None:
+        """Show only agents that have sessions.
+
+        Args:
+            agents: Set of agent names that have at least one session.
+        """
+        for filter_key, btn in self._filter_buttons.items():
+            if filter_key is None:
+                # "All" button is always visible
+                btn.display = True
+            elif filter_key in agents:
+                btn.display = True
+            else:
+                btn.display = False

fast_resume/tui/modal.py

@@ -0,0 +1,73 @@
+"""Modal dialogs for the TUI."""
+
+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, Label
+
+from .styles import YOLO_MODAL_CSS
+
+
+class YoloModeModal(ModalScreen[bool]):
+    """Modal to choose yolo mode for resume."""
+
+    BINDINGS = [
+        Binding("y", "select_yolo", "Yolo Mode", show=False),
+        Binding("n", "select_normal", "Normal", show=False),
+        Binding("escape", "dismiss", "Cancel", show=False),
+        Binding("enter", "select_focused", "Select", show=False),
+        Binding("left", "focus_normal", "Left", show=False),
+        Binding("right", "focus_yolo", "Right", show=False),
+    ]
+
+    CSS = YOLO_MODAL_CSS
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Label("Resume with yolo mode?", id="title")
+            with Horizontal(id="buttons"):
+                yield Button("No", id="normal-btn")
+                yield Button("Yolo", id="yolo-btn")
+
+    def on_mount(self) -> None:
+        """Focus the first button when modal opens."""
+        self.query_one("#normal-btn", Button).focus()
+
+    def action_toggle_focus(self) -> None:
+        """Toggle focus between the two buttons."""
+        if self.focused and self.focused.id == "yolo-btn":
+            self.query_one("#normal-btn", Button).focus()
+        else:
+            self.query_one("#yolo-btn", Button).focus()
+
+    def action_focus_normal(self) -> None:
+        """Focus the normal button."""
+        self.query_one("#normal-btn", Button).focus()
+
+    def action_focus_yolo(self) -> None:
+        """Focus the yolo button."""
+        self.query_one("#yolo-btn", Button).focus()
+
+    def action_select_focused(self) -> None:
+        """Select whichever button is currently focused."""
+        focused = self.focused
+        if focused and focused.id == "yolo-btn":
+            self.dismiss(True)
+        else:
+            self.dismiss(False)
+
+    def action_select_yolo(self) -> None:
+        self.dismiss(True)
+
+    def action_select_normal(self) -> None:
+        self.dismiss(False)
+
+    @on(Button.Pressed, "#yolo-btn")
+    def on_yolo_pressed(self) -> None:
+        self.dismiss(True)
+
+    @on(Button.Pressed, "#normal-btn")
+    def on_normal_pressed(self) -> None:
+        self.dismiss(False)

fast_resume/tui/preview.py

@@ -0,0 +1,396 @@
+"""Session preview widget for the TUI."""
+
+import re
+from io import StringIO
+from pathlib import Path
+from typing import Any
+
+from rich.columns import Columns
+from rich.console import Console, Group, RenderableType
+from rich.markup import escape as escape_markup
+from rich.syntax import Syntax
+from rich.text import Text
+from textual.widgets import Static
+from textual_image.renderable import Image as ImageRenderable
+
+from ..adapters.base import Session
+from ..config import AGENTS
+from .utils import highlight_matches
+
+# Asset paths for agent icons
+ASSETS_DIR = Path(__file__).parent.parent / "assets"
+
+# Cache for agent icon renderables
+_preview_icon_cache: dict[str, Any] = {}
+
+
+def _get_agent_icon(agent: str) -> RenderableType | None:
+    """Get the icon renderable for an agent."""
+    if agent not in _preview_icon_cache:
+        icon_path = ASSETS_DIR / f"{agent}.png"
+        if icon_path.exists():
+            try:
+                _preview_icon_cache[agent] = ImageRenderable(
+                    icon_path, width=2, height=1
+                )
+            except Exception:
+                _preview_icon_cache[agent] = None
+        else:
+            _preview_icon_cache[agent] = None
+    return _preview_icon_cache[agent]
+
+
+class SessionPreview(Static):
+    """Preview pane showing session content."""
+
+    # Highlight style for matches in preview
+    MATCH_STYLE = "bold reverse"
+    # Max lines to show for a single assistant message (None = no limit)
+    MAX_ASSISTANT_LINES: int | None = None
+
+    # Pattern to match code blocks with optional language
+    CODE_BLOCK_PATTERN = re.compile(r"```(\w*)")
+
+    def __init__(self) -> None:
+        super().__init__("", id="preview")
+
+    def update_preview(self, session: Session | None, query: str = "") -> None:
+        """Update the preview with session content, highlighting matches."""
+        if session is None:
+            self.update("")
+            return
+
+        result = self._build_preview_renderable(session, query)
+        self.update(result)
+
+    def _build_preview_renderable(
+        self, session: Session, query: str = ""
+    ) -> RenderableType:
+        """Build the preview renderable with icons. Returns a Group of renderables."""
+        content = session.content
+        preview_text = ""
+
+        # If there's a query, try to show the part containing the match
+        if query:
+            query_lower = query.lower()
+            content_lower = content.lower()
+            terms = query_lower.split()
+
+            # Find the first matching term
+            best_pos = -1
+            for term in terms:
+                if term:
+                    pos = content_lower.find(term)
+                    if pos != -1 and (best_pos == -1 or pos < best_pos):
+                        best_pos = pos
+
+            if best_pos != -1:
+                # Show context around the match (start 200 chars before, up to 5000 chars)
+                start = max(0, best_pos - 200)
+                end = min(len(content), start + 5000)
+                preview_text = content[start:end]
+                if start > 0:
+                    preview_text = "..." + preview_text
+                if end < len(content):
+                    preview_text = preview_text + "..."
+
+        # Fall back to full content (limited) if no match found
+        if not preview_text:
+            preview_text = content[:5000]
+            if len(content) > 5000:
+                preview_text += "..."
+
+        # Get agent config and icon
+        agent_config = AGENTS.get(
+            session.agent, {"color": "white", "badge": session.agent}
+        )
+        agent_icon = _get_agent_icon(session.agent)
+
+        # Build list of renderables
+        renderables: list[RenderableType] = []
+
+        # Split by double newlines to get individual messages
+        messages = preview_text.split("\n\n")
+
+        for i, msg in enumerate(messages):
+            msg = msg.rstrip()
+            if not msg.strip():
+                continue
+
+            # Detect if this is a user message
+            is_user = msg.startswith("» ")
+
+            if is_user:
+                # User message - render as text
+                text = Text()
+                self._render_message(text, msg, query, is_user, agent_config)
+                renderables.append(text)
+            else:
+                # Assistant message - add icon + text
+                if agent_icon is not None:
+                    # Create icon with text on same line using Columns
+                    text = Text()
+                    self._render_message_content(text, msg, query, agent_config)
+                    renderables.append(Columns([agent_icon, text], padding=(0, 1)))
+                else:
+                    # Fallback to badge
+                    text = Text()
+                    self._render_message(text, msg, query, is_user, agent_config)
+                    renderables.append(text)
+
+        return Group(*renderables)
+
+    def build_preview_text(self, session: Session, query: str = "") -> Text:
+        """Build the preview text for a session. Returns a Rich Text object."""
+        content = session.content
+        preview_text = ""
+
+        # If there's a query, try to show the part containing the match
+        if query:
+            query_lower = query.lower()
+            content_lower = content.lower()
+            terms = query_lower.split()
+
+            # Find the first matching term
+            best_pos = -1
+            for term in terms:
+                if term:
+                    pos = content_lower.find(term)
+                    if pos != -1 and (best_pos == -1 or pos < best_pos):
+                        best_pos = pos
+
+            if best_pos != -1:
+                # Show context around the match (start 200 chars before, up to 5000 chars)
+                start = max(0, best_pos - 200)
+                end = min(len(content), start + 5000)
+                preview_text = content[start:end]
+                if start > 0:
+                    preview_text = "..." + preview_text
+                if end < len(content):
+                    preview_text = preview_text + "..."
+
+        # Fall back to full content (limited) if no match found
+        if not preview_text:
+            preview_text = content[:5000]
+            if len(content) > 5000:
+                preview_text += "..."
+
+        # Build rich text with role-based styling
+        result = Text()
+
+        # Get agent config for styling
+        agent_config = AGENTS.get(
+            session.agent, {"color": "white", "badge": session.agent}
+        )
+
+        # Split by double newlines to get individual messages
+        messages = preview_text.split("\n\n")
+
+        for i, msg in enumerate(messages):
+            msg = (
+                msg.rstrip()
+            )  # Only strip trailing whitespace, preserve leading indent
+            if not msg.strip():  # Skip if empty after stripping
+                continue
+
+            # Detect if this is a user message
+            is_user = msg.startswith("» ")
+
+            # Process message with code block handling
+            self._render_message(result, msg, query, is_user, agent_config)
+
+        return result
+
+    def _render_message(
+        self,
+        result: Text,
+        msg: str,
+        query: str,
+        is_user: bool,
+        agent_config: dict[str, str],
+    ) -> None:
+        """Render a single message with code block syntax highlighting."""
+        lines = msg.split("\n")
+
+        # Truncate assistant messages if limit is set
+        if (
+            not is_user
+            and self.MAX_ASSISTANT_LINES is not None
+            and len(lines) > self.MAX_ASSISTANT_LINES
+        ):
+            lines = lines[: self.MAX_ASSISTANT_LINES]
+            lines.append("...")
+
+        # Add role prefix on first line
+        first_line = True
+
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+
+            # Check for code block start
+            match = self.CODE_BLOCK_PATTERN.match(line)
+            if match:
+                language = match.group(1) or ""
+                # Collect code block content
+                code_lines = []
+                i += 1
+                while i < len(lines) and not lines[i].startswith("```"):
+                    code_lines.append(lines[i])
+                    i += 1
+
+                # Render code block with syntax highlighting
+                if code_lines:
+                    code = "\n".join(code_lines)
+                    self._render_code_with_highlighting(result, code, language)
+
+                # Skip closing ```
+                if i < len(lines) and lines[i].startswith("```"):
+                    i += 1
+                continue
+
+            # Handle user prompt
+            if line.startswith("» "):
+                result.append("» ", style="bold cyan")
+                content_part = escape_markup(line[2:])
+                if len(content_part) > 200:
+                    content_part = content_part[:200].rsplit(" ", 1)[0] + " ..."
+                highlighted = highlight_matches(
+                    content_part, query, style=self.MATCH_STYLE
+                )
+                result.append_text(highlighted)
+                result.append("\n")
+                first_line = False
+            elif line == "...":
+                result.append("   ⋯\n", style="dim")
+            elif line.startswith("..."):
+                # Truncation indicator from context
+                result.append(escape_markup(line) + "\n", style="dim")
+            elif line.startswith("  "):
+                # Assistant response (indented) - add agent prefix on first line
+                if first_line:
+                    agent_color = agent_config["color"]
+                    result.append("● ", style=agent_color)
+                    result.append(agent_config["badge"], style=f"bold {agent_color}")
+                    result.append(" ")
+                    # Remove leading indent for first line since we added prefix
+                    content = line.lstrip()
+                    first_line = False
+                else:
+                    content = line
+                highlighted = highlight_matches(
+                    escape_markup(content), query, style=self.MATCH_STYLE
+                )
+                result.append_text(highlighted)
+                result.append("\n")
+            else:
+                # Other content
+                highlighted = highlight_matches(
+                    escape_markup(line), query, style=self.MATCH_STYLE
+                )
+                result.append_text(highlighted)
+                result.append("\n")
+
+            i += 1
+
+    def _render_message_content(
+        self,
+        result: Text,
+        msg: str,
+        query: str,
+        agent_config: dict[str, str],
+    ) -> None:
+        """Render assistant message content without badge (icon shown separately)."""
+        lines = msg.split("\n")
+
+        # Truncate assistant messages if limit is set
+        if (
+            self.MAX_ASSISTANT_LINES is not None
+            and len(lines) > self.MAX_ASSISTANT_LINES
+        ):
+            lines = lines[: self.MAX_ASSISTANT_LINES]
+            lines.append("...")
+
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+
+            # Check for code block start
+            match = self.CODE_BLOCK_PATTERN.match(line)
+            if match:
+                language = match.group(1) or ""
+                code_lines = []
+                i += 1
+                while i < len(lines) and not lines[i].startswith("```"):
+                    code_lines.append(lines[i])
+                    i += 1
+
+                if code_lines:
+                    code = "\n".join(code_lines)
+                    self._render_code_with_highlighting(result, code, language)
+
+                if i < len(lines) and lines[i].startswith("```"):
+                    i += 1
+                continue
+
+            if line == "...":
+                result.append("⋯\n", style="dim")
+            elif line.startswith("..."):
+                result.append(escape_markup(line) + "\n", style="dim")
+            elif line.startswith("  "):
+                # Assistant response - strip leading indent
+                content = line.lstrip()
+                highlighted = highlight_matches(
+                    escape_markup(content), query, style=self.MATCH_STYLE
+                )
+                result.append_text(highlighted)
+                result.append("\n")
+            else:
+                highlighted = highlight_matches(
+                    escape_markup(line), query, style=self.MATCH_STYLE
+                )
+                result.append_text(highlighted)
+                result.append("\n")
+
+            i += 1
+
+    def _render_code_with_highlighting(
+        self, result: Text, code: str, language: str
+    ) -> None:
+        """Render code with syntax highlighting."""
+        # Map common language aliases
+        lang_map = {
+            "js": "javascript",
+            "ts": "typescript",
+            "py": "python",
+            "rb": "ruby",
+            "sh": "bash",
+            "yml": "yaml",
+            "": "text",
+        }
+        language = lang_map.get(language, language) or "text"
+
+        try:
+            syntax = Syntax(
+                code,
+                language,
+                theme="ansi_dark",
+                line_numbers=False,
+                word_wrap=True,
+                background_color="default",
+            )
+            # Rich Syntax objects can be converted to Text
+            string_io = StringIO()
+            console = Console(file=string_io, force_terminal=True, width=200)
+            console.print(syntax, end="")
+            highlighted_code = string_io.getvalue()
+
+            # Add with indentation
+            for line in highlighted_code.rstrip().split("\n"):
+                result.append("  ")
+                result.append_text(Text.from_ansi(line))
+                result.append("\n")
+        except Exception:
+            # Fall back to plain dim text
+            for line in code.split("\n"):
+                result.append("  " + escape_markup(line) + "\n", style="dim")

fast_resume/tui/query.py

@@ -0,0 +1,86 @@
+"""Query parsing utilities for search keyword syntax."""
+
+import re
+
+from ..config import AGENTS
+
+# Pattern to match keyword:value syntax in search queries (with optional - prefix)
+KEYWORD_PATTERN = re.compile(r"(-?)(agent:|dir:|date:)(\S+)")
+
+# Valid date keywords and pattern
+VALID_DATE_KEYWORDS = {"today", "yesterday", "week", "month"}
+DATE_PATTERN = re.compile(r"^([<>])?(\d+)(m|h|d|w|mo|y)$")
+
+# Pattern to match agent: keyword specifically (for extraction/replacement)
+AGENT_KEYWORD_PATTERN = re.compile(r"-?agent:(\S+)")
+
+
+def is_valid_filter_value(keyword: str, value: str) -> bool:
+    """Check if a filter value is valid for the given keyword."""
+    check_value = value.lstrip("!")
+    values = [v.strip().lstrip("!") for v in check_value.split(",") if v.strip()]
+
+    if keyword == "agent:":
+        return all(v.lower() in AGENTS for v in values)
+    elif keyword == "date:":
+        for v in values:
+            v_lower = v.lower()
+            if v_lower not in VALID_DATE_KEYWORDS and not DATE_PATTERN.match(v_lower):
+                return False
+        return True
+    elif keyword == "dir:":
+        return True  # Any value is valid for directory
+    return True
+
+
+def extract_agent_from_query(query: str) -> str | None:
+    """Extract agent value from query string if present.
+
+    Returns the first non-negated agent value, or None if no agent keyword.
+    For mixed filters like agent:claude,!codex, returns 'claude'.
+    """
+    match = AGENT_KEYWORD_PATTERN.search(query)
+    if not match:
+        return None
+
+    # Check if the whole keyword is negated with - prefix
+    full_match = match.group(0)
+    if full_match.startswith("-"):
+        return None  # Negated filter, don't sync to buttons
+
+    value = match.group(1)
+    # Handle ! prefix on value
+    if value.startswith("!"):
+        return None  # Negated, don't sync
+
+    # Get first non-negated value from comma-separated list
+    for v in value.split(","):
+        v = v.strip()
+        if v and not v.startswith("!"):
+            return v
+
+    return None
+
+
+def update_agent_in_query(query: str, agent: str | None) -> str:
+    """Update or remove agent keyword in query string.
+
+    Args:
+        query: Current query string
+        agent: Agent to set, or None to remove agent keyword
+
+    Returns:
+        Updated query string with agent keyword added/updated/removed.
+    """
+    # Remove existing agent keyword(s)
+    query_without_agent = AGENT_KEYWORD_PATTERN.sub("", query).strip()
+    # Clean up extra whitespace
+    query_without_agent = " ".join(query_without_agent.split())
+
+    if agent is None:
+        return query_without_agent
+
+    # Append agent keyword at the end
+    if query_without_agent:
+        return f"{query_without_agent} agent:{agent}"
+    return f"agent:{agent}"