fast-resume 1.12.8__py3-none-any.whl

fast_resume/logging_config.py

@@ -0,0 +1,57 @@
+"""Logging configuration for fast-resume."""
+
+import logging
+from pathlib import Path
+
+from .config import CACHE_DIR, LOG_FILE
+
+# Module logger for parse errors
+parse_logger = logging.getLogger("fast_resume.parse_errors")
+
+
+def setup_logging() -> None:
+    """Set up logging with file handler for parse errors.
+
+    Logs are written to ~/.cache/fast-resume/parse-errors.log
+    """
+    # Ensure cache directory exists
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Configure parse error logger
+    parse_logger.setLevel(logging.WARNING)
+
+    # Avoid duplicate handlers if called multiple times
+    if not parse_logger.handlers:
+        # File handler - append mode, rotates on size
+        handler = logging.FileHandler(LOG_FILE, mode="a", encoding="utf-8")
+        handler.setLevel(logging.WARNING)
+
+        # Format: timestamp - level - message
+        formatter = logging.Formatter(
+            "%(asctime)s - %(levelname)s - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+        handler.setFormatter(formatter)
+        parse_logger.addHandler(handler)
+
+        # Don't propagate to root logger (avoid console output)
+        parse_logger.propagate = False
+
+
+def log_parse_error(
+    agent: str, file_path: str | Path, error_type: str, message: str
+) -> None:
+    """Log a parse error to the log file.
+
+    Args:
+        agent: Which adapter encountered the error (e.g., "claude", "codex")
+        file_path: Path to the problematic file
+        error_type: Exception type name (e.g., "JSONDecodeError")
+        message: Human-readable error message
+    """
+    parse_logger.warning("[%s] %s in %s: %s", agent, error_type, file_path, message)
+
+
+def get_log_file_path() -> Path:
+    """Return the path to the log file."""
+    return LOG_FILE

fast_resume/query.py

@@ -0,0 +1,264 @@
+"""Query parser for keyword-based search syntax.
+
+Supports syntax like: `agent:claude,codex dir:my-project date:<1d api auth`
+
+Keywords:
+- agent: Filter by agent name (supports multiple: agent:claude,codex)
+- dir: Filter by directory (substring match, supports multiple: dir:proj1,proj2)
+- date: Filter by date (today, yesterday, <1h, >1d, etc.)
+
+Negation:
+- Use ! prefix on value: agent:!claude (exclude claude)
+- Use - prefix on keyword: -agent:claude (exclude claude)
+"""
+
+import re
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from enum import Enum
+
+
+class DateOp(Enum):
+    """Date filter comparison operator."""
+
+    EXACT = "exact"  # today, yesterday
+    LESS_THAN = "<"  # <1h (within the last hour)
+    GREATER_THAN = ">"  # >1d (older than 1 day)
+
+
+@dataclass
+class DateFilter:
+    """Parsed date filter."""
+
+    op: DateOp
+    value: str  # Original value for display
+    cutoff: datetime  # The cutoff datetime for comparison
+    negated: bool = False  # True if filter should exclude matches
+
+
+@dataclass
+class Filter:
+    """A filter with multiple possible values and negation support.
+
+    Supports mixed include/exclude: agent:claude,!codex means
+    "match claude but not codex".
+    """
+
+    include: list[str] = field(default_factory=list)  # Values to match (OR logic)
+    exclude: list[str] = field(default_factory=list)  # Values to exclude (AND logic)
+
+    @property
+    def values(self) -> list[str]:
+        """All values (for backward compat and display)."""
+        return self.include + self.exclude
+
+    @property
+    def negated(self) -> bool:
+        """True if filter is exclude-only (for backward compat)."""
+        return len(self.include) == 0 and len(self.exclude) > 0
+
+    def matches(self, value: str, substring: bool = False) -> bool:
+        """Check if value matches this filter.
+
+        Args:
+            value: The value to check
+            substring: If True, check if any filter value is a substring
+
+        Returns:
+            True if the value matches include list (or no include list)
+            AND doesn't match exclude list.
+        """
+        if not self.include and not self.exclude:
+            return True
+
+        def check(filter_val: str) -> bool:
+            if substring:
+                return filter_val.lower() in value.lower()
+            return value == filter_val
+
+        # Check excludes first - if any match, reject
+        if any(check(v) for v in self.exclude):
+            return False
+
+        # If no includes, accept (exclude-only filter)
+        if not self.include:
+            return True
+
+        # Check includes - at least one must match
+        return any(check(v) for v in self.include)
+
+
+@dataclass
+class ParsedQuery:
+    """Result of parsing a search query."""
+
+    text: str  # Free-text search terms
+    agent: Filter | None  # Extracted agent filter
+    directory: Filter | None  # Extracted directory filter
+    date: DateFilter | None  # Extracted date filter
+
+
+# Pattern to match keyword:value pairs with optional - prefix for negation
+# Handles: agent:value, -agent:value, dir:"value with spaces", date:<1h
+_KEYWORD_PATTERN = re.compile(
+    r"(-?)"  # optional negation prefix
+    r"(agent|dir|date):"  # keyword prefix
+    r'(?:"([^"]+)"|(\S+))'  # quoted value or unquoted value
+)
+
+# Pattern to parse relative time like <1h, >2d, <30m
+_RELATIVE_TIME_PATTERN = re.compile(
+    r"^([<>])?(\d+)(m|h|d|w|mo|y)$"  # operator, number, unit
+)
+
+# Time unit multipliers (in seconds)
+_TIME_UNITS = {
+    "m": 60,  # minutes
+    "h": 3600,  # hours
+    "d": 86400,  # days
+    "w": 604800,  # weeks
+    "mo": 2592000,  # months (30 days)
+    "y": 31536000,  # years (365 days)
+}
+
+
+def _parse_date_value(value: str, negated: bool = False) -> DateFilter | None:
+    """Parse a date filter value into a DateFilter.
+
+    Supports:
+    - today: sessions from today
+    - yesterday: sessions from yesterday
+    - <Nu: sessions newer than N units (e.g., <1h, <2d)
+    - >Nu: sessions older than N units (e.g., >1h, >2d)
+    - Nu: same as <Nu (default to "within")
+    """
+    now = datetime.now()
+
+    # Handle ! prefix for negation in value
+    if value.startswith("!"):
+        value = value[1:]
+        negated = True
+
+    value_lower = value.lower()
+
+    # Handle named dates
+    if value_lower == "today":
+        cutoff = now.replace(hour=0, minute=0, second=0, microsecond=0)
+        return DateFilter(op=DateOp.EXACT, value=value, cutoff=cutoff, negated=negated)
+    elif value_lower == "yesterday":
+        cutoff = (now - timedelta(days=1)).replace(
+            hour=0, minute=0, second=0, microsecond=0
+        )
+        return DateFilter(op=DateOp.EXACT, value=value, cutoff=cutoff, negated=negated)
+    elif value_lower == "week":
+        cutoff = now - timedelta(days=7)
+        return DateFilter(
+            op=DateOp.LESS_THAN, value=value, cutoff=cutoff, negated=negated
+        )
+    elif value_lower == "month":
+        cutoff = now - timedelta(days=30)
+        return DateFilter(
+            op=DateOp.LESS_THAN, value=value, cutoff=cutoff, negated=negated
+        )
+
+    # Handle relative time patterns
+    match = _RELATIVE_TIME_PATTERN.match(value_lower)
+    if match:
+        op_str, num_str, unit = match.groups()
+        num = int(num_str)
+        seconds = num * _TIME_UNITS[unit]
+        cutoff = now - timedelta(seconds=seconds)
+
+        if op_str == ">":
+            return DateFilter(
+                op=DateOp.GREATER_THAN, value=value, cutoff=cutoff, negated=negated
+            )
+        else:  # < or no operator defaults to "within"
+            return DateFilter(
+                op=DateOp.LESS_THAN, value=value, cutoff=cutoff, negated=negated
+            )
+
+    return None
+
+
+def _parse_filter_value(value: str, negated: bool) -> Filter:
+    """Parse a filter value, handling ! prefix and comma-separated values.
+
+    Args:
+        value: The filter value (e.g., "claude", "claude,codex", "claude,!codex")
+        negated: True if the keyword had - prefix (e.g., -agent:claude)
+
+    Returns:
+        Filter with values sorted into include/exclude lists.
+    """
+    include: list[str] = []
+    exclude: list[str] = []
+
+    # Split comma-separated values
+    raw_values = [v.strip() for v in value.split(",") if v.strip()]
+
+    for val in raw_values:
+        # Check for ! prefix on individual value
+        if val.startswith("!"):
+            exclude.append(val[1:])
+        elif negated:
+            # Whole filter negated with - prefix
+            exclude.append(val)
+        else:
+            include.append(val)
+
+    return Filter(include=include, exclude=exclude)
+
+
+def parse_query(query: str) -> ParsedQuery:
+    """Parse keyword syntax from query string.
+
+    Args:
+        query: Raw query string like "agent:claude,codex dir:my-project date:<1d api"
+
+    Returns:
+        ParsedQuery with extracted filters and remaining free-text.
+
+    Examples:
+        >>> parse_query("agent:claude api auth")
+        ParsedQuery(text="api auth", agent=Filter(include=["claude"]), ...)
+
+        >>> parse_query("agent:claude,codex api")  # Multiple values (OR)
+        ParsedQuery(text="api", agent=Filter(include=["claude", "codex"]), ...)
+
+        >>> parse_query("-agent:claude api")  # Negation (exclude all)
+        ParsedQuery(text="api", agent=Filter(exclude=["claude"]), ...)
+
+        >>> parse_query("agent:!claude api")  # Negation (exclude specific)
+        ParsedQuery(text="api", agent=Filter(exclude=["claude"]), ...)
+
+        >>> parse_query("agent:claude,!codex api")  # Mixed include/exclude
+        ParsedQuery(text="api", agent=Filter(include=["claude"], exclude=["codex"]), ...)
+    """
+    agent: Filter | None = None
+    directory: Filter | None = None
+    date: DateFilter | None = None
+
+    # Find all keyword matches and track their positions
+    matches = list(_KEYWORD_PATTERN.finditer(query))
+
+    # Extract keyword values (last one wins if duplicates)
+    for match in matches:
+        neg_prefix = match.group(1) == "-"
+        keyword = match.group(2)
+        # Value is either quoted (group 3) or unquoted (group 4)
+        value = match.group(3) or match.group(4)
+
+        if keyword == "agent":
+            agent = _parse_filter_value(value, neg_prefix)
+        elif keyword == "dir":
+            directory = _parse_filter_value(value, neg_prefix)
+        elif keyword == "date":
+            date = _parse_date_value(value, neg_prefix)
+
+    # Remove keyword:value pairs from query to get free-text
+    text = _KEYWORD_PATTERN.sub("", query)
+    # Clean up extra whitespace
+    text = " ".join(text.split())
+
+    return ParsedQuery(text=text, agent=agent, directory=directory, date=date)

fast_resume/search.py

@@ -0,0 +1,281 @@
+"""Search engine for aggregating and searching sessions."""
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Callable
+
+from .adapters import (
+    ClaudeAdapter,
+    CodexAdapter,
+    CopilotAdapter,
+    CopilotVSCodeAdapter,
+    CrushAdapter,
+    ErrorCallback,
+    OpenCodeAdapter,
+    Session,
+    VibeAdapter,
+)
+from .index import TantivyIndex
+from .query import Filter, parse_query
+
+
+class SessionSearch:
+    """Aggregates sessions from all adapters and provides search.
+
+    Uses Tantivy as the single source of truth for session data.
+    """
+
+    def __init__(self) -> None:
+        self.adapters = [
+            ClaudeAdapter(),
+            CodexAdapter(),
+            CopilotAdapter(),
+            CopilotVSCodeAdapter(),
+            CrushAdapter(),
+            OpenCodeAdapter(),
+            VibeAdapter(),
+        ]
+        self._sessions: list[Session] | None = None
+        self._sessions_by_id: dict[str, Session] = {}
+        self._streaming_in_progress: bool = False
+        self._index = TantivyIndex()
+
+    def _load_from_index(self) -> list[Session] | None:
+        """Try to load sessions from index if no changes detected (fast path for TUI)."""
+        # Get known sessions from Tantivy
+        known = self._index.get_known_sessions()
+        if not known:
+            return None
+
+        # Check if any adapter has changes
+        for adapter in self.adapters:
+            new_or_modified, deleted_ids = adapter.find_sessions_incremental(known)
+            if new_or_modified or deleted_ids:
+                # Changes detected - need full update
+                return None
+
+        # No changes - load from index
+        sessions = self._index.get_all_sessions()
+        if not sessions:
+            return None
+
+        # Populate sessions_by_id
+        for session in sessions:
+            self._sessions_by_id[session.id] = session
+
+        return sessions
+
+    def get_all_sessions(self, force_refresh: bool = False) -> list[Session]:
+        """Get all sessions from all adapters with incremental updates."""
+        if self._sessions is not None and not force_refresh:
+            return self._sessions
+
+        # If streaming is in progress, return current partial results
+        if self._streaming_in_progress:
+            return self._sessions if self._sessions is not None else []
+
+        # Get known sessions from Tantivy for incremental comparison
+        known = self._index.get_known_sessions() if not force_refresh else {}
+
+        # Ask each adapter for changes
+        all_new_or_modified: list[Session] = []
+        all_deleted_ids: list[str] = []
+
+        def get_incremental(adapter):
+            return adapter.find_sessions_incremental(known)
+
+        with ThreadPoolExecutor(max_workers=len(self.adapters)) as executor:
+            results = executor.map(get_incremental, self.adapters)
+            for new_or_modified, deleted_ids in results:
+                all_new_or_modified.extend(new_or_modified)
+                all_deleted_ids.extend(deleted_ids)
+
+        # If no changes and we have data in index, load from index
+        if not all_new_or_modified and not all_deleted_ids and known:
+            self._sessions = self._index.get_all_sessions()
+            for session in self._sessions:
+                self._sessions_by_id[session.id] = session
+            self._sessions.sort(key=lambda s: s.timestamp, reverse=True)
+            return self._sessions
+
+        # Apply deletions to index
+        self._index.delete_sessions(all_deleted_ids)
+
+        # Update modified sessions atomically (delete + add in single transaction)
+        self._index.update_sessions(all_new_or_modified)
+
+        # Load all sessions from index
+        self._sessions = self._index.get_all_sessions()
+        for session in self._sessions:
+            self._sessions_by_id[session.id] = session
+
+        # Sort by timestamp, newest first
+        self._sessions.sort(key=lambda s: s.timestamp, reverse=True)
+
+        return self._sessions
+
+    def get_sessions_streaming(
+        self,
+        on_progress: Callable[[], None],
+        on_error: ErrorCallback = None,
+    ) -> tuple[list[Session], int, int, int]:
+        """Load sessions with progress callback for each adapter that completes.
+
+        Sessions are indexed incrementally as each adapter completes, allowing
+        Tantivy search to work during streaming.
+
+        Args:
+            on_progress: Callback for progress updates
+            on_error: Optional callback for parse errors
+
+        Returns:
+            Tuple of (sessions, new_count, updated_count, deleted_count)
+        """
+        # Get known sessions from Tantivy
+        known = self._index.get_known_sessions()
+
+        # Pre-populate _sessions_by_id with existing sessions from index
+        # so search() can find them during streaming
+        existing_sessions = self._index.get_all_sessions()
+        for session in existing_sessions:
+            self._sessions_by_id[session.id] = session
+
+        # Mark streaming as in progress
+        self._streaming_in_progress = True
+        total_new = 0
+        total_updated = 0
+        total_deleted = 0
+
+        def get_incremental(adapter):
+            return adapter.find_sessions_incremental(known, on_error=on_error)
+
+        try:
+            with ThreadPoolExecutor(max_workers=len(self.adapters)) as executor:
+                futures = {
+                    executor.submit(get_incremental, a): a for a in self.adapters
+                }
+                for future in as_completed(futures):
+                    new_or_modified, deleted_ids = future.result()
+
+                    # Skip if no changes from this adapter
+                    if not new_or_modified and not deleted_ids:
+                        continue
+
+                    # Handle deletions first
+                    if deleted_ids:
+                        self._index.delete_sessions(deleted_ids)
+                        for sid in deleted_ids:
+                            self._sessions_by_id.pop(sid, None)
+                        total_deleted += len(deleted_ids)
+
+                    # Index incrementally + update _sessions_by_id for search lookup
+                    if new_or_modified:
+                        # Update atomically (delete + add in single transaction)
+                        self._index.update_sessions(new_or_modified)
+                        for session in new_or_modified:
+                            self._sessions_by_id[session.id] = session
+                            # Count new vs updated
+                            if session.id in known:
+                                total_updated += 1
+                            else:
+                                total_new += 1
+
+                    # Notify progress - TUI will query the index
+                    on_progress()
+        finally:
+            self._streaming_in_progress = False
+
+        # Load final state from index
+        self._sessions = self._index.get_all_sessions()
+        for session in self._sessions:
+            self._sessions_by_id[session.id] = session
+        self._sessions.sort(key=lambda s: s.timestamp, reverse=True)
+
+        return self._sessions, total_new, total_updated, total_deleted
+
+    def search(
+        self,
+        query: str,
+        agent_filter: str | None = None,
+        directory_filter: str | None = None,
+        limit: int = 100,
+    ) -> list[Session]:
+        """Search sessions using Tantivy full-text search with fuzzy matching.
+
+        Supports keyword syntax in the query:
+        - agent:value,value2 - Filter by agent (comma for OR, ! or - for NOT)
+        - dir:value - Filter by directory (substring match)
+        - date:value - Filter by date (today, yesterday, <1h, >1d, etc.)
+
+        Explicit filter parameters take precedence over keywords in the query.
+        All filtering is done at the Tantivy level for efficiency.
+        """
+        # Parse keyword syntax from query
+        parsed = parse_query(query)
+        search_text = parsed.text
+
+        # Merge filters: explicit params take precedence over parsed keywords
+        # Convert string params to Filter objects for consistency
+        if agent_filter is not None:
+            effective_agent: Filter | None = Filter(include=[agent_filter])
+        else:
+            effective_agent = parsed.agent
+
+        if directory_filter is not None:
+            effective_dir: Filter | None = Filter(include=[directory_filter])
+        else:
+            effective_dir = parsed.directory
+
+        date_filter = parsed.date
+
+        # During streaming, _sessions_by_id is updated incrementally
+        # Only call get_all_sessions() if not streaming and no sessions loaded yet
+        if not self._streaming_in_progress and self._sessions is None:
+            self.get_all_sessions()
+
+        # Use Tantivy for all searching and filtering
+        results = self._index.search(
+            search_text,
+            agent_filter=effective_agent,
+            directory_filter=effective_dir,
+            date_filter=date_filter,
+            limit=limit,
+        )
+
+        # Lookup full session objects from results
+        matched_sessions = []
+        for session_id, _score in results:
+            session = self._sessions_by_id.get(session_id)
+            if session:
+                matched_sessions.append(session)
+
+        return matched_sessions
+
+    def get_session_count(self, agent_filter: str | None = None) -> int:
+        """Get the total number of sessions in the index.
+
+        Args:
+            agent_filter: If provided, only count sessions for this agent.
+        """
+        return self._index.get_session_count(agent_filter)
+
+    def get_agents_with_sessions(self) -> set[str]:
+        """Get the set of agent names that have at least one session."""
+        agents = set()
+        for adapter in self.adapters:
+            if self._index.get_session_count(adapter.name) > 0:
+                agents.add(adapter.name)
+        return agents
+
+    def get_adapter_for_session(self, session: Session):
+        """Get the adapter for a session."""
+        for adapter in self.adapters:
+            if adapter.name == session.agent:
+                return adapter
+        return None
+
+    def get_resume_command(self, session: Session, yolo: bool = False) -> list[str]:
+        """Get the resume command for a session."""
+        adapter = self.get_adapter_for_session(session)
+        if adapter:
+            return adapter.get_resume_command(session, yolo=yolo)
+        return []

fast_resume/tui/__init__.py

@@ -0,0 +1,58 @@
+"""TUI package for fast-resume."""
+
+from .. import __version__
+from .app import FastResumeApp
+from .search_input import KeywordSuggester
+from .modal import YoloModeModal
+from .preview import SessionPreview
+from .utils import (
+    ASSETS_DIR,
+    _icon_cache,
+    copy_to_clipboard,
+    format_directory,
+    format_time_ago,
+    get_age_color,
+    get_agent_icon,
+    highlight_matches,
+)
+
+
+def run_tui(
+    query: str = "",
+    agent_filter: str | None = None,
+    yolo: bool = False,
+    no_version_check: bool = False,
+) -> tuple[list[str] | None, str | None]:
+    """Run the TUI and return the resume command and directory if selected."""
+    app = FastResumeApp(
+        initial_query=query,
+        agent_filter=agent_filter,
+        yolo=yolo,
+        no_version_check=no_version_check,
+    )
+    app.run()
+
+    if not no_version_check and app._available_update:
+        print(
+            f"\nUpdate available: {__version__} → {app._available_update}\n"
+            f"Run: uv tool upgrade fast-resume"
+        )
+
+    return app.get_resume_command(), app.get_resume_directory()
+
+
+__all__ = [
+    "run_tui",
+    "FastResumeApp",
+    "KeywordSuggester",
+    "YoloModeModal",
+    "SessionPreview",
+    "ASSETS_DIR",
+    "copy_to_clipboard",
+    "format_directory",
+    "format_time_ago",
+    "get_age_color",
+    "get_agent_icon",
+    "highlight_matches",
+    "_icon_cache",
+]