jnav 1.0.0__py3-none-any.whl

jnav/role_mapper.py

@@ -0,0 +1,53 @@
+from typing import Any
+
+from aioreactive import AsyncSubject
+
+from jnav.field_mapping import FieldMapping, detect_role_updates
+from jnav.store import IndexedEntry
+
+
+class RoleMapper:
+    """Tracks fields discovered in the data and the timestamp/level/message role mapping."""
+
+    on_change: AsyncSubject[None]
+
+    def __init__(self) -> None:
+        self._all_fields: set[str] = set()
+        self._mapping: FieldMapping = FieldMapping()
+        self.on_change = AsyncSubject[None]()
+
+    @property
+    def all_fields(self) -> set[str]:
+        return self._all_fields
+
+    @property
+    def mapping(self) -> FieldMapping:
+        return self._mapping
+
+    async def discover(self, entries: list[IndexedEntry]) -> None:
+        """Discover fields from a list of entries. Updates the mapping if new roles are detected."""
+        for ie in entries:
+            await self.discover_from_entry(ie.entry.expanded)
+
+    async def discover_from_entry(self, entry: dict[str, Any]) -> None:
+        """Discover fields from a single entry. Updates the mapping if new roles are detected."""
+        new_fields = entry.keys() - self._all_fields
+        self._all_fields.update(new_fields)
+
+        updates = detect_role_updates(self._mapping, entry, new_fields)
+
+        if not updates:
+            return
+
+        self._mapping = self._mapping.model_copy(update=updates)
+        await self.on_change.asend(None)
+
+    async def set_mapping(
+        self,
+        mapping_data: dict[str, Any] | FieldMapping | None,
+    ) -> None:
+        if mapping_data:
+            self._mapping = FieldMapping.model_validate(mapping_data)
+        else:
+            self._mapping = FieldMapping()
+        await self.on_change.asend(None)

jnav/scrollbar_overlay.py

@@ -0,0 +1,79 @@
+from collections.abc import Generator
+
+from rich.color import Color
+from rich.console import Console, ConsoleOptions, RenderableType
+from rich.segment import Segment
+from rich.style import Style
+
+
+def _get_bg_at(line: list[Segment], position: int) -> Color | None:
+    pos = 0
+    for seg in line:
+        pos += seg.cell_length
+        if pos > position:
+            return seg.style.bgcolor if seg.style else None
+    return None
+
+
+class ScrollbarOverlay:
+    """A Rich renderable that overlays a scrollbar thumb on inner content.
+
+    Renders the inner content normally, but on lines within the thumb region,
+    truncates the line by one character and appends a scrollbar indicator.
+    The thumb character inherits the background color from the content beneath it.
+    """
+
+    def __init__(
+        self,
+        inner: RenderableType,
+        *,
+        total_items: int,
+        visible_count: int,
+        scroll_position: int,
+        thumb_style: Style,
+    ) -> None:
+        self._inner = inner
+        self._total_items = total_items
+        self._visible_count = visible_count
+        self._scroll_position = scroll_position
+        self._thumb_style = thumb_style
+
+    def _compute_thumb(self, viewport_height: int) -> tuple[int, int]:
+        max_scroll = self._total_items - self._visible_count
+        if max_scroll <= 0:
+            return 0, 0
+        thumb_size = max(
+            1, round(viewport_height * self._visible_count / self._total_items)
+        )
+        fraction = self._scroll_position / max_scroll
+        thumb_top = round(fraction * (viewport_height - thumb_size))
+        thumb_top = max(0, min(thumb_top, viewport_height - thumb_size))
+        return thumb_top, thumb_top + thumb_size
+
+    def __rich_console__(
+        self,
+        console: Console,
+        options: ConsoleOptions,
+    ) -> Generator[Segment]:
+        width = options.max_width
+        height = options.height or options.max_height
+
+        thumb_top, thumb_end = self._compute_thumb(height)
+
+        segments = console.render(self._inner, options)
+        for y, line in enumerate(Segment.split_lines(segments)):
+            # Yield the line as-is if it's outside the thumb region
+            if not (thumb_top <= y < thumb_end):
+                yield from line
+                yield Segment.line()
+                continue
+
+            # Truncate the line to make room for the scrollbar
+            truncated = Segment.adjust_line_length(list(line), width - 1)
+            yield from truncated
+
+            # Get the background color of the wrapped renderable
+            bg = _get_bg_at(line, width - 1)
+
+            yield Segment("┃", Style(color=self._thumb_style.color, bgcolor=bg))
+            yield Segment.line()

jnav/search_engine.py

@@ -0,0 +1,87 @@
+from typing import Any, cast
+
+from aioreactive import AsyncSubject
+
+from jnav.log_model import LogModel
+from jnav.store import IndexedEntry
+
+
+def entry_matches_search(entry: dict[str, Any], term_lower: str) -> bool:
+    def _check(obj: object) -> bool:
+        if isinstance(obj, str):
+            return term_lower in obj.lower()
+        if isinstance(obj, dict):
+            obj = cast(dict[str, Any], obj)
+            return any(_check(v) for v in obj.values())
+        if isinstance(obj, list):
+            obj = cast(list[Any], obj)
+            return any(_check(item) for item in obj)
+        return term_lower in str(obj).lower()
+
+    return _check(entry)
+
+
+class SearchEngine:
+    on_change: AsyncSubject[None]
+
+    def __init__(self, model: LogModel) -> None:
+        self._model = model
+        self._term: str = ""
+        self._matches: list[int] = []
+        self.on_change = AsyncSubject[None]()
+
+    @property
+    def term(self) -> str:
+        return self._term
+
+    @property
+    def matches(self) -> list[int]:
+        return self._matches
+
+    @property
+    def active(self) -> bool:
+        return bool(self._term)
+
+    async def start(self) -> None:
+        await self._model.on_rebuild.subscribe_async(self._on_rebuild)
+        await self._model.on_append.subscribe_async(self._on_append)
+
+    async def set_term(self, term: str) -> None:
+        self._term = term
+        self._recompute_all()
+        await self.on_change.asend(None)
+
+    async def clear(self) -> None:
+        self._term = ""
+        self._matches = []
+        await self.on_change.asend(None)
+
+    def _recompute_all(self) -> None:
+        if not self._term:
+            self._matches = []
+            return
+        term_lower = self._term.lower()
+        self._matches = [
+            ie.index
+            for ie in self._model.all()
+            if entry_matches_search(ie.entry.expanded, term_lower)
+        ]
+
+    async def _on_rebuild(self, _: None) -> None:
+        if not self._term:
+            return
+        self._recompute_all()
+        await self.on_change.asend(None)
+
+    async def _on_append(self, new_entries: list[IndexedEntry]) -> None:
+        if not self._term:
+            return
+        term_lower = self._term.lower()
+        new_matches = [
+            ie.index
+            for ie in new_entries
+            if entry_matches_search(ie.entry.expanded, term_lower)
+        ]
+        if new_matches:
+            self._matches.extend(new_matches)
+            await self.on_change.asend(None)

jnav/selector_manager_screen.py

@@ -0,0 +1,187 @@
+from typing import TYPE_CHECKING, ClassVar, override
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Footer, OptionList
+from textual.widgets.option_list import Option
+
+from jnav.manager_screen_common import list_option_prompt
+from jnav.selector_provider import SelectorProvider
+from jnav.text_input_screen import TextInputScreen
+
+if TYPE_CHECKING:
+    from textual import getters
+    from textual.app import App
+
+
+class SelectorManagerScreen(ModalScreen[bool]):
+    if TYPE_CHECKING:
+        app = getters.app(App[None])
+
+    DEFAULT_CSS = """
+    SelectorManagerScreen {
+        align: center middle;
+    }
+    #selector-modal {
+        width: 60;
+        max-width: 90%;
+        height: auto;
+        max-height: 70%;
+        border: round $primary;
+        background: $background;
+    }
+    #selector-wrapper {
+        padding: 1 2;
+        height: auto;
+    }
+    #selector-list {
+        height: auto;
+        max-height: 14;
+        border: none;
+    }
+    #selector-modal Footer {
+        background: transparent;
+    }
+    #selector-modal FooterKey .footer-key--key {
+        color: $primary;
+    }
+    """
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("escape", "maybe_close", "Close", priority=True, show=False),
+        Binding("q", "maybe_close", show=False),
+        Binding("ctrl+c", "maybe_close", show=False),
+        Binding("a", "add", "Add"),
+        Binding("e", "edit", "Edit"),
+        Binding("d", "delete", "Cut"),
+        Binding("y", "yank", "Yank"),
+        Binding("p", "paste", "Paste"),
+        Binding("t", "toggle_item", "Toggle"),
+        Binding("j", "cursor_down", show=False),
+        Binding("k", "cursor_up", show=False),
+    ]
+
+    def __init__(self, selector_provider: SelectorProvider) -> None:
+        super().__init__()
+        self._sp = selector_provider
+        self._clipboard: str | None = None
+
+    @override
+    def compose(self) -> ComposeResult:
+        yield Vertical(
+            Vertical(
+                OptionList(id="selector-list"),
+                id="selector-wrapper",
+            ),
+            Footer(),
+            id="selector-modal",
+        )
+
+    def on_mount(self) -> None:
+        self.query_one("#selector-modal").border_title = "Selectors"
+        self._refresh_list(highlight=0)
+        self.query_one("#selector-list", OptionList).focus()
+
+    def _refresh_list(self, highlight: int | None = None) -> None:
+        selectors = self._sp.selectors
+        ol = self.query_one("#selector-list", OptionList)
+        ol.clear_options()
+        if not selectors:
+            ol.add_option(Option(Text(" (no selectors)", style="dim"), disabled=True))
+        else:
+            for s in selectors:
+                ol.add_option(list_option_prompt(s["path"], s["enabled"]))
+        if highlight is not None and selectors:
+            ol.highlighted = min(highlight, len(selectors) - 1)
+
+    def action_cursor_down(self) -> None:
+        self.query_one("#selector-list", OptionList).action_cursor_down()
+
+    def action_cursor_up(self) -> None:
+        self.query_one("#selector-list", OptionList).action_cursor_up()
+
+    async def action_toggle_item(self) -> None:
+        ol = self.query_one("#selector-list", OptionList)
+        idx = ol.highlighted
+        if idx is not None and idx < len(self._sp.selectors):
+            await self._sp.toggle_selector(idx)
+            self._refresh_list(idx)
+
+    async def action_delete(self) -> None:
+        ol = self.query_one("#selector-list", OptionList)
+        idx = ol.highlighted
+        selectors = self._sp.selectors
+        if idx is None or idx >= len(selectors):
+            return
+        self._clipboard = selectors[idx]["path"]
+        await self._sp.remove_selector(idx)
+        self._refresh_list(idx)
+
+    def action_yank(self) -> None:
+        ol = self.query_one("#selector-list", OptionList)
+        idx = ol.highlighted
+        selectors = self._sp.selectors
+        if idx is None or idx >= len(selectors):
+            return
+        self._clipboard = selectors[idx]["path"]
+
+    async def action_paste(self) -> None:
+        if self._clipboard is None:
+            return
+        ol = self.query_one("#selector-list", OptionList)
+        idx = ol.highlighted
+        target = (idx + 1) if idx is not None else len(self._sp.selectors)
+        await self._sp.insert_selector(target, self._clipboard)
+        self._clipboard = None
+        self._refresh_list(target)
+
+    def action_add(self) -> None:
+        ol = self.query_one("#selector-list", OptionList)
+        idx = ol.highlighted
+        target = (idx + 1) if idx is not None else len(self._sp.selectors)
+
+        async def on_dismiss(value: str | None) -> None:
+            if not value:
+                return
+            path = value.strip()
+            if not path:
+                return
+            await self._sp.insert_selector(target, path)
+            self._refresh_list(target)
+
+        self.app.push_screen(
+            TextInputScreen("Add selector", placeholder="jq selector..."),
+            on_dismiss,
+        )
+
+    def action_edit(self) -> None:
+        ol = self.query_one("#selector-list", OptionList)
+        idx = ol.highlighted
+        selectors = self._sp.selectors
+        if idx is None or idx >= len(selectors):
+            return
+        current = selectors[idx]["path"]
+
+        async def on_dismiss(value: str | None) -> None:
+            if not value:
+                return
+            path = value.strip()
+            if not path:
+                return
+            await self._sp.edit_selector(idx, path)
+            self._refresh_list(idx)
+
+        self.app.push_screen(
+            TextInputScreen(
+                "Edit selector",
+                placeholder="jq selector...",
+                initial_value=current,
+            ),
+            on_dismiss,
+        )
+
+    def action_maybe_close(self) -> None:
+        self.dismiss(True)

jnav/selector_provider.py

@@ -0,0 +1,64 @@
+from typing import TypedDict
+
+from aioreactive import AsyncSubject
+
+
+class Selector(TypedDict):
+    path: str
+    enabled: bool
+
+
+class SelectorProvider:
+    """Tracks user-defined jq selectors for extracting values from entries."""
+
+    on_change: AsyncSubject[None]
+
+    def __init__(self) -> None:
+        self._selectors: list[Selector] = []
+        self.on_change = AsyncSubject[None]()
+
+    @property
+    def selectors(self) -> list[Selector]:
+        return list(self._selectors)
+
+    @property
+    def active_selectors(self) -> set[str]:
+        return {s["path"] for s in self._selectors if s["enabled"]}
+
+    def has_selector(self, path: str) -> bool:
+        return any(s["path"] == path for s in self._selectors)
+
+    async def add_selector(self, path: str) -> None:
+        self._selectors.append({"path": path, "enabled": True})
+        await self.on_change.asend(None)
+
+    async def insert_selector(self, index: int, path: str) -> None:
+        self._selectors.insert(index, {"path": path, "enabled": True})
+        await self.on_change.asend(None)
+
+    async def remove_selector(self, index: int) -> None:
+        self._selectors.pop(index)
+        await self.on_change.asend(None)
+
+    async def remove_selector_by_path(self, path: str) -> None:
+        for i, s in enumerate(self._selectors):
+            if s["path"] == path:
+                self._selectors.pop(i)
+                await self.on_change.asend(None)
+                return
+
+    async def toggle_selector(self, index: int) -> None:
+        self._selectors[index]["enabled"] = not self._selectors[index]["enabled"]
+        await self.on_change.asend(None)
+
+    async def edit_selector(self, index: int, path: str) -> None:
+        self._selectors[index]["path"] = path
+        await self.on_change.asend(None)
+
+    async def set_selectors(self, selectors: list[Selector]) -> None:
+        self._selectors = list(selectors)
+        await self.on_change.asend(None)
+
+    async def clear_selectors(self) -> None:
+        self._selectors.clear()
+        await self.on_change.asend(None)

jnav/store.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+
+from aioreactive import AsyncSubject
+
+from jnav.parsing import ParsedEntry
+
+LogEntry = ParsedEntry
+
+
+@dataclass(frozen=True)
+class IndexedEntry:
+    index: int
+    entry: LogEntry
+
+
+class Store:
+    entries: list[LogEntry]
+    on_append: AsyncSubject[list[IndexedEntry]]
+
+    def __init__(self) -> None:
+        self.entries = []
+        self.on_append = AsyncSubject[list[IndexedEntry]]()
+
+    async def append_entries(self, new_entries: list[LogEntry]) -> None:
+        start = len(self.entries)
+        self.entries.extend(new_entries)
+        indexed = [IndexedEntry(start + i, e) for i, e in enumerate(new_entries)]
+        await self.on_append.asend(indexed)
+
+    def get(self, index: int) -> IndexedEntry:
+        return IndexedEntry(index, self.entries[index])
+
+    def all(self) -> list[IndexedEntry]:
+        return [IndexedEntry(i, e) for i, e in enumerate(self.entries)]
+
+    def __len__(self) -> int:
+        return len(self.entries)

jnav/text_input_screen.py

@@ -0,0 +1,63 @@
+from typing import ClassVar, override
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.screen import ModalScreen
+from textual.widgets import Input
+
+
+class TextInputScreen(ModalScreen[str | None]):
+    DEFAULT_CSS = """
+    TextInputScreen {
+        align: center middle;
+    }
+    #text-input {
+        width: 50;
+        max-width: 90%;
+        height: 3;
+        border: round $primary;
+        background: $background;
+        padding: 0 2;
+        margin: 0;
+
+        &:focus {
+            background-tint: transparent;
+        }
+    }
+    """
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("escape", "close", "Close", priority=True),
+        Binding("ctrl+c", "close", show=False),
+    ]
+
+    def __init__(
+        self,
+        title: str = "Search",
+        placeholder: str = "search term...",
+        initial_value: str = "",
+    ) -> None:
+        super().__init__()
+        self._title = title
+        self._placeholder = placeholder
+        self._initial_value = initial_value
+
+    @override
+    def compose(self) -> ComposeResult:
+        yield Input(placeholder=self._placeholder, id="text-input")
+
+    def on_mount(self) -> None:
+        self.query_one("#text-input").border_title = self._title
+        inp = self.query_one("#text-input", Input)
+        if self._initial_value:
+            inp.value = self._initial_value
+        inp.focus()
+
+    @on(Input.Submitted, "#text-input")
+    def on_submitted(self, event: Input.Submitted) -> None:
+        term = event.value.strip()
+        self.dismiss(term if term else None)
+
+    def action_close(self) -> None:
+        self.dismiss(None)