jsonl-cli 0.1.2__py3-none-any.whl

jsonl_cli/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

jsonl_cli/cli.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+import argparse
+import curses
+import os
+from typing import List, Optional
+
+from .colors import _hex_to_rgb, _key_to_pair_id, _rgb_to_xterm256, _load_theme
+from .render import _render_json_styled, _wrap_styled_lines
+from .helpers import _validate_path, _build_offsets, _human_bytes, \
+                     _read_line_at, _scan_brief, _parse_row, _die
+from .command import _apply_command, _prompt_command
+from .search import SearchSpec, _find_next, _parse_search_spec
+
+
+def _viewer(stdscr: "curses._CursesWindow", path: str, theme: str) -> None:
+    """
+    Main driver code for the curses window.
+    
+    Args:
+        stdscr: The curses window to display to.
+        path:   Path to the JSONL file.
+    """
+    curses.curs_set(0)
+    
+    status_msg: str | None = None
+    
+    curses.start_color()
+    try:
+        curses.use_default_colors()
+    except curses.error:
+        pass
+    
+    color_theme = _load_theme(theme)
+
+    num_pairs = len(color_theme)
+    for i, hx in enumerate(color_theme, start=1):
+        r, g, b = _hex_to_rgb(hx)
+        fg = _rgb_to_xterm256(r, g, b)
+        try:
+            curses.init_pair(i, fg, -1)
+        except curses.error:
+            pass
+
+    def key_attr_fn(key: str) -> int:
+        pid = _key_to_pair_id(key, num_pairs)
+        return curses.A_BOLD | curses.color_pair(pid)
+
+    normal_attr = curses.A_NORMAL
+    
+    stdscr.keypad(True)
+
+    offsets = _build_offsets(path)
+    total_lines = max(0, len(offsets) - 1)
+
+    idx = 0
+    scroll = 0
+    indent_delta = 4
+    last_search: SearchSpec | None = None
+
+    def apply_search(raw: str, include_current: bool = False, direction: int = 1) -> None:
+        nonlocal idx, scroll, status_msg, last_search
+        spec, err = _parse_search_spec(raw)
+        if err:
+            status_msg = err
+            return
+
+        hit = _find_next(path, offsets, total_lines, idx, spec, direction, include_current)
+        last_search = spec
+        if hit is None:
+            status_msg = f"no match: {spec.label()}"
+            return
+
+        idx = hit.idx
+        scroll = 0
+        prefix = "wrapped to " if hit.wrapped else ""
+        status_msg = f"{prefix}row {idx + 1}: {spec.label()}"
+
+    def repeat_search(direction: int) -> None:
+        nonlocal idx, scroll, status_msg
+        if last_search is None:
+            status_msg = "no previous search"
+            return
+
+        hit = _find_next(path, offsets, total_lines, idx, last_search, direction, False)
+        if hit is None:
+            status_msg = f"no match: {last_search.label()}"
+            return
+
+        idx = hit.idx
+        scroll = 0
+        prefix = "wrapped to " if hit.wrapped else ""
+        status_msg = f"{prefix}row {idx + 1}: {last_search.label()}"
+
+    while True:
+        height, width = stdscr.getmaxyx()
+        stdscr.erase()
+
+        if total_lines == 0:
+            stdscr.addnstr(0, 0, "Empty file. Press q to quit.", width - 1)
+            stdscr.refresh()
+            ch = stdscr.getch()
+            if ch in (ord("q"), ord("Q")):
+                return
+            continue
+
+        if idx < 0:
+            idx = 0
+        if idx >= total_lines:
+            idx = total_lines - 1
+
+        start = offsets[idx]
+        end = offsets[idx + 1]
+        raw = _read_line_at(path, start, end)
+        row = _parse_row(raw, idx)
+
+        header = f"{os.path.basename(path)}  |  {idx + 1}/{total_lines}  |  ↑/↓ scroll  ←/→ row  / find  n/N next/prev  q quit"
+        stdscr.addnstr(0, 0, header, max(0, width - 1), curses.A_REVERSE)
+
+        title = row.title
+        stdscr.addnstr(1, 0, title, max(0, width - 1), curses.A_BOLD)
+
+        content_height = max(0, height - 3)
+        content_width = max(1, width - 1)
+
+        if row.ok:
+            styled_lines = _render_json_styled(row.obj, 0, key_attr_fn, normal_attr, indent_delta)
+        else:
+            raw = row.raw_fallback or ""
+            styled_lines = [[(raw, curses.A_DIM)]]
+
+        styled_lines = _wrap_styled_lines(styled_lines, content_width)
+
+        max_scroll = max(0, len(styled_lines) - content_height)
+        if scroll > max_scroll:
+            scroll = max_scroll
+        if scroll < 0:
+            scroll = 0
+
+        view = styled_lines[scroll : scroll + content_height]
+
+        for i, line in enumerate(view):
+            y = 2 + i
+            x = 0
+            remaining = content_width
+            for text, attr in line:
+                if remaining <= 0:
+                    break
+                if not text:
+                    continue
+                chunk = text[:remaining]
+                try:
+                    stdscr.addstr(y, x, chunk, attr)
+                except curses.error:
+                    pass
+                x += len(chunk)
+                remaining -= len(chunk)
+
+        footer = status_msg
+        if footer is None and max_scroll > 0:
+            footer = f"Lines {scroll} - {min(scroll + content_height, len(styled_lines))}"
+        if footer and height > 0:
+            stdscr.addnstr(height - 1, 0, footer, max(0, width - 1), curses.A_DIM)
+
+        stdscr.refresh()
+        ch = stdscr.getch()
+
+        if ch in (ord("q"), ord("Q")):
+            return
+        elif ch == ord(":"):
+            cmd = _prompt_command(stdscr, prompt=":")
+            status_msg = None
+            if cmd is not None:
+                parts = cmd.split(maxsplit=1)
+                name = parts[0].lower() if parts else ""
+                if name in ("find", "f", "search", "s"):
+                    apply_search(parts[1] if len(parts) == 2 else "", include_current=True)
+                elif name in ("next", "n"):
+                    repeat_search(1)
+                elif name in ("prev", "previous", "p"):
+                    repeat_search(-1)
+                else:
+                    new_idx, msg = _apply_command(cmd, total_lines, idx)
+                    if new_idx == -1:
+                        return
+                    idx = new_idx
+                    scroll = 0
+                    status_msg = msg
+        elif ch == ord("/"):
+            cmd = _prompt_command(stdscr, prompt="/")
+            status_msg = None
+            if cmd is not None:
+                apply_search(cmd, include_current=True)
+        elif ch == ord("n"):
+            repeat_search(1)
+        elif ch == ord("N"):
+            repeat_search(-1)
+        elif ch == curses.KEY_DOWN:
+            scroll += 1
+        elif ch == curses.KEY_UP:
+            scroll -= 1
+        elif ch == curses.KEY_LEFT:
+            idx -= 1
+            scroll = 0
+        elif ch == curses.KEY_RIGHT:
+            idx += 1
+            scroll = 0
+        elif ch in (curses.KEY_NPAGE,):
+            indent_delta = max(indent_delta - 1, 1)
+        elif ch in (curses.KEY_PPAGE,):
+            indent_delta = min(indent_delta + 1, 8)
+        elif ch == curses.KEY_RESIZE:
+            pass
+        else:
+            pass
+
+
+def main(argv: Optional[List[str]] = None) -> None:
+    parser = argparse.ArgumentParser(prog="jsonl", add_help=True)
+    parser.add_argument("file", metavar="FILE", help="Path to a .jsonl file")
+    parser.add_argument("-b", "--brief", action="store_true", help="Show file characteristics and exit")
+    parser.add_argument("-t", "--theme", metavar="STR", type=str, default="catppuccin-mocha", help="Color theme")
+    args = parser.parse_args(argv)
+
+    path = _validate_path(args.file)
+
+    if args.brief:
+        line_count, size, cols, invalid = _scan_brief(path)
+        print(f"File: {path}")
+        print(f"Size: {_human_bytes(size)} ({size} bytes)")
+        print(f"Lines: {line_count}")
+        if invalid:
+            print(f"Invalid JSON lines: {invalid}")
+        print("Columns:")
+        if cols:
+            for c in cols:
+                print(f"  - {c}")
+        else:
+            print("  (no object keys found)")
+        return
+
+    try:
+        curses.wrapper(_viewer, path, args.theme)
+    except KeyboardInterrupt:
+        return
+    except curses.error as e:
+        _die(f"curses error: {e}", code=1)

jsonl_cli/colors.py

@@ -0,0 +1,84 @@
+import zlib
+import json
+from pathlib import Path
+from typing import List
+
+
+def _hex_to_rgb(h: str) -> tuple[int, int, int]:
+    """
+    Converts a hex color string into RGB values.
+    
+    Args:
+        h: The hex string.
+    
+    Returns:
+        A 3-tuple of the RGB values in base 16, each between 00 and FF inclusive.
+    """
+    h = h.lstrip("#")
+    return (int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16))
+
+
+def _rgb_to_xterm256(r: int, g: int, b: int) -> int:
+    """
+    Maps 24-bit RGB values to xterm-256 color indices.
+    Will always map the closest possible color.
+    
+    Args:
+        r: The base 16 value for red.
+        g: The base 16 value for green.
+        b: The base 16 value for blue.
+    
+    Returns:
+        The index of the corresponding xterm-256 color.
+    """
+    if r == g == b:
+        if r < 8:
+            return 16
+        if r > 248:
+            return 231
+        return 232 + (r - 8) // 10
+
+    def to_6(x: int) -> int:
+        return int(round(x / 255 * 5))
+
+    rr, gg, bb = to_6(r), to_6(g), to_6(b)
+    return 16 + 36 * rr + 6 * gg + bb
+
+
+def _key_to_pair_id(key: str, num_pairs: int) -> int:
+    """
+    Maps a string to a color via hashing.
+    Uses zlib.crc32() as the hash function.
+    
+    Args:
+        key:       The string to assign a color to.
+        num_pairs: The number of colors that can be assigned.
+        
+    Returns:
+        The index in curses corresponding to that color.
+        Note that index 0 in curses corresponds to the default text color, so the return value is 1-indexed.
+    """
+    h = zlib.crc32(key.encode("utf-8")) & 0xFFFFFFFF
+    return 1 + (h % num_pairs)
+
+
+def _load_theme(theme: str) -> List[str]:
+    """
+    Loads a theme's hex colors.
+    
+    Args:
+        theme: Name of the theme.
+    
+    Returns:
+        A list of strings that represent hex colors for that theme.
+    """
+    try:
+        path = Path(__file__).parent / "themes" / f"{theme}.json"
+        with path.open("r", encoding="utf-8") as f:
+            data = json.load(f)
+        return data["key-colors"]
+    except:
+        path = Path(__file__).parent / "themes" / "catppuccin-mocha.json" # Default
+        with path.open("r", encoding="utf-8") as f:
+            data = json.load(f)
+        return data["key-colors"]

jsonl_cli/command.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import curses
+
+
+def _prompt_command(stdscr: "curses._CursesWindow", prompt: str = ":") -> str | None:
+    """
+    Read a command from the bottom line.
+
+    Args:
+        stdscr: The curses window to display to.
+        prompt: The prompt / command to read.
+    
+    Returns:
+        The command string (without leading ':') or None if cancelled (ESC).
+    """
+    height, width = stdscr.getmaxyx()
+    y = height - 1
+
+    buf: list[str] = []
+    pos = 0
+
+    stdscr.move(y, 0)
+    stdscr.clrtoeol()
+    stdscr.addnstr(y, 0, prompt, width - 1, curses.A_REVERSE)
+    stdscr.refresh()
+
+    while True:
+        ch = stdscr.get_wch()
+
+        if ch == "\x1b":
+            return None
+
+        if ch in ("\n", "\r"):
+            return "".join(buf).strip()
+
+        if ch in (curses.KEY_BACKSPACE, "\b", "\x7f"):
+            if pos > 0:
+                buf.pop(pos - 1)
+                pos -= 1
+
+        elif ch == curses.KEY_LEFT:
+            pos = max(0, pos - 1)
+        elif ch == curses.KEY_RIGHT:
+            pos = min(len(buf), pos + 1)
+        elif ch == curses.KEY_HOME:
+            pos = 0
+        elif ch == curses.KEY_END:
+            pos = len(buf)
+        elif isinstance(ch, str) and ch.isprintable():
+            buf.insert(pos, ch)
+            pos += 1
+
+        cmd_text = prompt + "".join(buf)
+        if len(cmd_text) >= width:
+            cmd_text = cmd_text[-(width - 1):]
+        stdscr.move(y, 0)
+        stdscr.clrtoeol()
+        stdscr.addnstr(y, 0, cmd_text, width - 1, curses.A_REVERSE)
+
+        cursor_x = min(width - 1, len(prompt) + pos)
+        stdscr.move(y, cursor_x)
+        stdscr.refresh()
+
+
+def _apply_command(cmd: str, total_lines: int, idx: int) -> tuple[int, str | None]:
+    """
+    Applies a command string.
+    
+    Args:
+        cmd:         The command inputted.
+        total_lines: The number of rows in the JSONL file.
+        idx:         The current index being viewed.
+    
+    Returns:
+        A tuple (new_idx, status_message_or_None).
+    """
+    if not cmd:
+        return idx, None
+
+    parts = cmd.split()
+    name = parts[0].lower()
+
+    if name in ("goto", "g") and len(parts) == 2:
+        try:
+            n = int(parts[1])
+        except ValueError:
+            return idx, "goto expects an integer row number"
+
+        if total_lines <= 0:
+            return idx, "file has no rows"
+
+        n = max(1, min(total_lines, n))
+        return n - 1, None
+
+    if name in ("q", "quit", "exit"):
+        return -1, None
+
+    return idx, f"unknown command: {cmd}"

jsonl_cli/containers.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+from typing import Any, Optional
+
+# We use this datastructure since different portions of 1 line need to have different curses bitmasks (due to colors and bolding).
+Segment = tuple[str, int]  # (raw_text, curses_attribute_bitmask)
+StyledLine = list[Segment] # 1 Line in the output
+
+# A container for 1 JSONL row.
+@dataclass
+class RowData:
+    ok: bool                            # Whether the line has been successfully parsed to JSON.
+    title: str                          # The status for the row displayed at the top of the window.
+    obj: Any = None                     # The parsed Python object for this JSONL row.
+    raw_fallback: Optional[str] = None  # Fallback raw JSONL text for failed formatting.

jsonl_cli/helpers.py

@@ -0,0 +1,161 @@
+import sys
+import json
+import os
+from typing import List, Tuple
+
+from .containers import RowData
+
+def _die(msg: str, code: int = 2) -> None:
+    """
+    Raises SystemExit.
+    
+    Args:
+        msg:  The message to display to the user.
+        code: The system exit code.
+    
+    Raises:
+        SystemExit unconditionally.
+    """
+    print(f"jsonl: {msg}", file=sys.stderr)
+    raise SystemExit(code)
+
+
+def _human_bytes(n: int) -> str:
+    """
+    Converts number of bytes into a human-readable form.
+    
+    Args:
+        n: The number of bytes to convert.
+    
+    Returns:
+        The human-readable conversion of n bytes.
+    """
+    units = ["B", "KiB", "MiB", "GiB", "TiB"]
+    x = float(n)
+    for u in units:
+        if x < 1024.0 or u == units[-1]:
+            if u == "B":
+                return f"{int(x)} {u}"
+            return f"{x:.2f} {u}"
+        x /= 1024.0
+    return f"{n} B"
+
+
+def _validate_path(path: str) -> str:
+    """
+    Validates whether a path is a valid JSONL file.
+    
+    Args:
+        path: The path to the JSONL file.
+    
+    Returns:
+        The given path without modification.
+
+    Raises:
+        SystemExit if path is abnormal.
+    """
+    if not path.endswith(".jsonl"):
+        _die("FILE must end with .jsonl")
+    if not os.path.exists(path):
+        _die(f"FILE not found: {path}")
+    if not os.path.isfile(path):
+        _die(f"FILE is not a regular file: {path}")
+    return path
+
+
+def _scan_brief(path: str) -> Tuple[int, int, List[str], int]:
+    """
+    Returns a summary of the given JSONL file.
+    Columns are the union of keys across all JSON objects that are dicts.
+    
+    Args:
+        path: The path to the JSONL file.
+    
+    Returns:
+        A 4-tuple of (line_count, file_size_bytes, columns_sorted, invalid_json_lines).
+    """
+    st = os.stat(path)
+    size = st.st_size
+    line_count = 0
+    invalid = 0
+    cols = set()
+
+    with open(path, "rb") as f:
+        for raw in f:
+            line_count += 1
+            line = raw.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+                if isinstance(obj, dict):
+                    cols.update(obj.keys())
+            except json.JSONDecodeError:
+                invalid += 1
+
+    return line_count, size, sorted(cols), invalid
+
+
+def _build_offsets(path: str) -> List[int]:
+    """
+    Builds file 0-indexed offsets for each line start.
+    
+    Args:
+        path: The path to the JSONL file.
+    
+    Returns:
+        A list of 0-indexed offsets of length equal to the number of lines in the JSONL file.
+    """
+    offsets: List[int] = []
+    pos = 0
+    
+    offsets.append(pos)
+    with open(path, "rb") as f:
+        for raw in f:
+            pos += len(raw)
+            offsets.append(pos)
+    
+    return offsets
+
+
+def _read_line_at(path: str, start: int, end: int) -> bytes:
+    """
+    Wrapper for reading lines of a file, i.e. start <= && < end
+    
+    Args:
+        path:  The path to the JSONL file.
+        start: The index of the byte to start reading.
+        end:   The index of the byte right after the byte to end reading.
+    
+    Returns:
+        A segment of bytes of the given JSONL file.
+    """
+    with open(path, "rb") as f:
+        f.seek(start)
+        return f.read(end - start)
+
+
+def _parse_row(raw_line: bytes, row_idx: int) -> RowData:
+    """
+    Parses raw bytes of a JSONL row into a RowData structure.
+    
+    Args:
+        raw_line: Bytes of the JSONL row.
+        row_idx:  0-indexed row number.
+    
+    Returns:
+        A RowData structure corresponding to the given row bytes.
+        
+    Raises:
+        JSONDecodeError if the row cannot be parsed.
+    """
+    s = raw_line.decode("utf-8", errors="replace").rstrip("\r\n")
+    if not s.strip():
+        return RowData(ok=True, title=f"Row {row_idx+1}: (empty line)", obj="")
+
+    try:
+        obj = json.loads(s)
+        return RowData(ok=True, title=f"Row {row_idx+1}: OK", obj=obj)
+    except json.JSONDecodeError as e:
+        msg = f"Row {row_idx+1}: INVALID JSON ({e.msg} at col {e.colno})"
+        return RowData(ok=False, title=msg, obj=None, raw_fallback=s)

jsonl_cli/render.py

@@ -0,0 +1,196 @@
+import json
+import curses
+from typing import Any
+
+from .containers import StyledLine
+
+def _json_atom(v: Any) -> str:
+    """
+    Convert a terminal endpoint in a JSONL file to a string.
+    
+    Args:
+        v: A terminal endpoint in the JSONL file, i.e. a value or an item in a list.
+    
+    Returns:
+        The string corresponding to the given terminal endpoint.
+    """
+    return json.dumps(v, ensure_ascii=False)
+
+
+def _render_json_styled(
+    v: Any,
+    indent: int,
+    key_attr_fn,
+    normal_attr: int,
+    indent_delta: int,
+) -> list[StyledLine]:
+    """
+    Recursively renders a Python object corresponding to 1 line in a JSONL file.
+    
+    Args:
+        v:            The Python object to render.
+        indent:       The base indent to use.
+        key_attr_fn:  Function that maps strings to curses bitmasks. Applies to keys.
+        normal_attr:  Function that maps strings to curses bitmasks. Applies to everything else.
+        indent_delta: Amount to indent each line.
+    
+    Returns:
+        The rendered Python object in a list of StyledLines.
+    """
+    lines: list[StyledLine] = []
+
+    is_root = (indent == 0)
+    
+    sp = " " * indent
+    sp_child = " " * (indent + indent_delta)
+
+    if isinstance(v, dict):
+        if is_root:
+            lines.append([(sp + "{", normal_attr)])
+        items = list(v.items())
+        for i, (k, val) in enumerate(items):
+            last = (i == len(items) - 1)
+
+            k_str = json.dumps(k, ensure_ascii=False)
+            k_attr = key_attr_fn(str(k))
+
+            if isinstance(val, (dict, list)):
+                opener = "{" if isinstance(val, dict) else "["
+                line: StyledLine = [
+                    (sp_child, normal_attr),
+                    (k_str, k_attr),
+                    (": " + opener, normal_attr),
+                ]
+                lines.append(line)
+                lines.extend(_render_json_styled(val, indent + indent_delta, key_attr_fn, normal_attr, indent_delta))
+                closer = "}" if isinstance(val, dict) else "]"
+                tail = closer + ("" if last else ",")
+                lines.append([(sp_child + tail, normal_attr)]) if lines[-1] else lines.append([(sp_child + tail, normal_attr)])
+            else:
+                atom = _json_atom(val)
+                comma = "" if last else ","
+                lines.append([
+                    (sp_child, normal_attr),
+                    (k_str, k_attr),
+                    (": " + atom + comma, normal_attr),
+                ])
+        if is_root:
+            lines.append([(sp + "}", normal_attr)])
+        
+        return lines
+
+    if isinstance(v, list):
+        if is_root:
+            lines.append([(sp + "[", normal_attr)])
+        
+        for i, item in enumerate(v):
+            last = (i == len(v) - 1)
+            if isinstance(item, (dict, list)):
+                opener = "{" if isinstance(item, dict) else "["
+                lines.append([(sp_child + opener, normal_attr)])
+                lines.extend(_render_json_styled(item, indent + indent_delta, key_attr_fn, normal_attr, indent_delta))
+                closer = "}" if isinstance(item, dict) else "]"
+                tail = closer + ("" if last else ",")
+                lines.append([(sp_child + tail, normal_attr)]) if lines[-1] else lines.append([(sp_child + tail, normal_attr)])
+            else:
+                atom = _json_atom(item)
+                comma = "" if last else ","
+                lines.append([(sp_child + atom + comma, normal_attr)])
+        
+        if is_root:
+            lines.append([(sp + "]", normal_attr)])
+        
+        return lines
+
+    lines.append([(sp + _json_atom(v), normal_attr)])
+    
+    return lines
+
+
+def _wrap_styled_lines(lines: list[StyledLine], width: int) -> list[StyledLine]:
+    """
+    Wrap styled lines to fit window width.
+    Preserves per-segment attributes and breaks only at character boundaries.
+    
+    Args:
+        lines: List of StyledLines to wrap.
+        width: Width to wrap to.
+        
+    Returns:
+        The resulting list of StyledLines that have been wrapped.
+    """
+    if width <= 1:
+        return lines
+
+    out: list[StyledLine] = []
+
+    for line in lines:
+        out_start = len(out)
+        rendered = "".join(t for t, _ in line)
+
+        sep = rendered.find(": ")
+        if sep != -1:
+            align = sep + 2
+        else:
+            align = 0
+            while align < len(rendered) and rendered[align] == " ":
+                align += 1
+
+        align = min(align, max(0, width - 1))
+
+        cur: StyledLine = []
+        cur_len = 0
+        needs_indent = False
+
+        def _append_indent() -> None:
+            nonlocal cur, cur_len, needs_indent
+            if needs_indent and align > 0:
+                cur.append((" " * align, curses.A_NORMAL))
+                cur_len += align
+            needs_indent = False
+
+        def _append(text: str, attr: int) -> None:
+            nonlocal cur, cur_len
+            if not text:
+                return
+            _append_indent()
+            if cur and cur[-1][1] == attr:
+                cur[-1] = (cur[-1][0] + text, attr)
+            else:
+                cur.append((text, attr))
+            cur_len += len(text)
+
+        def flush() -> None:
+            nonlocal cur, cur_len, needs_indent
+            out.append(cur if cur else [("", curses.A_NORMAL)])
+            cur = []
+            cur_len = 0
+            needs_indent = True
+
+        for text, attr in line:
+            if not text:
+                continue
+
+            i = 0
+            while i < len(text):
+                _append_indent()
+                space = width - cur_len
+                if space <= 0:
+                    flush()
+                    _append_indent()
+                    space = width - cur_len
+
+                chunk = text[i:i + space]
+                i += len(chunk)
+
+                _append(chunk, attr)
+
+                if cur_len >= width:
+                    flush()
+
+        if cur:
+            out.append(cur)
+        elif len(out) == out_start:
+            out.append([("", curses.A_NORMAL)])
+
+    return out

jsonl_cli/search.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from typing import Any, Iterable
+
+from .helpers import _parse_row, _read_line_at
+
+
+@dataclass(frozen=True)
+class SearchSpec:
+    query: str
+    paths: tuple[str, ...] = ()
+    case_sensitive: bool = False
+    regex: bool = False
+
+    def label(self) -> str:
+        scope = ",".join(self.paths) if self.paths else "all fields"
+        return f"{scope}: {self.query}"
+
+
+@dataclass(frozen=True)
+class SearchHit:
+    idx: int
+    wrapped: bool
+
+
+_PATHS_RE = re.compile(r"^([A-Za-z0-9_.*\[\]-]+(?:,[A-Za-z0-9_.*\[\]-]+)*):(.*)$")
+
+
+def _parse_search_spec(raw: str) -> tuple[SearchSpec | None, str | None]:
+    text = raw.strip()
+    if not text:
+        return None, "find expects a search string"
+
+    case_sensitive = False
+    regex = False
+
+    while True:
+        if text.startswith("-c "):
+            case_sensitive = True
+            text = text[3:].lstrip()
+        elif text.startswith("-r "):
+            regex = True
+            text = text[3:].lstrip()
+        else:
+            break
+
+    paths: tuple[str, ...] = ()
+    match = _PATHS_RE.match(text)
+    if match:
+        paths = tuple(p for p in match.group(1).split(",") if p)
+        text = match.group(2).strip()
+
+    query = _unquote(text)
+    if not query:
+        return None, "find expects a search string"
+
+    if regex:
+        try:
+            re.compile(query)
+        except re.error as e:
+            return None, f"invalid regex: {e.msg}"
+
+    return SearchSpec(query, paths, case_sensitive, regex), None
+
+
+def _find_next(
+    path: str,
+    offsets: list[int],
+    total_lines: int,
+    idx: int,
+    spec: SearchSpec,
+    direction: int = 1,
+    include_current: bool = False,
+) -> SearchHit | None:
+    if total_lines <= 0:
+        return None
+
+    direction = -1 if direction < 0 else 1
+    start = idx if include_current else idx + direction
+
+    for step in range(total_lines):
+        row_idx = (start + step * direction) % total_lines
+        start_byte = offsets[row_idx]
+        end_byte = offsets[row_idx + 1]
+        row = _parse_row(_read_line_at(path, start_byte, end_byte), row_idx)
+        if row.ok and _matches(row.obj, spec):
+            wrapped = row_idx < idx if direction > 0 else row_idx > idx
+            return SearchHit(row_idx, wrapped)
+
+    return None
+
+
+def _matches(obj: Any, spec: SearchSpec) -> bool:
+    values: Iterable[Any]
+    if spec.paths:
+        values = (value for path in spec.paths for value in _path_values(obj, path))
+    else:
+        values = (obj,)
+
+    return any(_text_matches(text, spec) for value in values for text in _search_texts(value))
+
+
+def _text_matches(text: str, spec: SearchSpec) -> bool:
+    if spec.regex:
+        flags = 0 if spec.case_sensitive else re.IGNORECASE
+        return re.search(spec.query, text, flags) is not None
+
+    needle = spec.query if spec.case_sensitive else spec.query.casefold()
+    haystack = text if spec.case_sensitive else text.casefold()
+    return needle in haystack
+
+
+def _search_texts(value: Any) -> Iterable[str]:
+    if isinstance(value, dict):
+        yield json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+        for k, v in value.items():
+            yield str(k)
+            yield from _search_texts(v)
+    elif isinstance(value, list):
+        yield json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+        for item in value:
+            yield from _search_texts(item)
+    else:
+        yield str(value)
+
+
+def _path_values(obj: Any, path: str) -> Iterable[Any]:
+    values = [obj]
+    for token in _path_tokens(path):
+        next_values: list[Any] = []
+        for value in values:
+            next_values.extend(_descend(value, token))
+        values = next_values
+        if not values:
+            break
+
+    return values
+
+
+def _path_tokens(path: str) -> list[str]:
+    tokens: list[str] = []
+    for part in path.split("."):
+        if not part:
+            continue
+        while part.endswith("[]"):
+            part = part[:-2]
+            if part:
+                tokens.append(part)
+                part = ""
+            tokens.append("*")
+        if part:
+            tokens.append(part)
+    return tokens
+
+
+def _descend(value: Any, token: str) -> list[Any]:
+    if token == "*":
+        if isinstance(value, dict):
+            return list(value.values())
+        if isinstance(value, list):
+            return list(value)
+        return []
+
+    if isinstance(value, dict):
+        return [value[token]] if token in value else []
+
+    if isinstance(value, list) and token.isdigit():
+        i = int(token)
+        return [value[i]] if i < len(value) else []
+
+    return []
+
+
+def _unquote(text: str) -> str:
+    if len(text) >= 2 and text[0] == text[-1] and text[0] in ("'", '"'):
+        return text[1:-1]
+    return text

jsonl_cli/themes/catppuccin-frappe.json

@@ -0,0 +1,18 @@
+{
+    "key-colors": [
+        "#f2d5cf",
+        "#eebebe",
+        "#f4b8e4",
+        "#ca9ee6",
+        "#e78284",
+        "#ea999c",
+        "#ef9f76",
+        "#e5c890",
+        "#a6d189",
+        "#81c8be",
+        "#99d1db",
+        "#85c1dc",
+        "#8caaee",
+        "#babbf1"
+    ]
+}

jsonl_cli/themes/catppuccin-latte.json

@@ -0,0 +1,18 @@
+{
+    "key-colors": [
+        "#dc8a78",
+        "#dd7878",
+        "#ea76cb",
+        "#8839ef",
+        "#d20f39",
+        "#e64553",
+        "#fe640b",
+        "#df8e1d",
+        "#40a02b",
+        "#179299",
+        "#04a5e5",
+        "#209fb5",
+        "#1e66f5",
+        "#7287fd"
+    ]
+}

jsonl_cli/themes/catppuccin-macchiato.json

@@ -0,0 +1,18 @@
+{
+    "key-colors": [
+        "#f4dbd6",
+        "#f0c6c6",
+        "#f5bde6",
+        "#c6a0f6",
+        "#ed8796",
+        "#ee99a0",
+        "#f5a97f",
+        "#eed49f",
+        "#a6da95",
+        "#8bd5ca",
+        "#91d7e3",
+        "#7dc4e4",
+        "#8aadf4",
+        "#b7bdf8"
+    ]
+}

jsonl_cli/themes/catppuccin-mocha.json

@@ -0,0 +1,18 @@
+{
+    "key-colors" : [
+        "#f5e0dc",
+        "#f2cdcd",
+        "#f5c2e7",
+        "#cba6f7",
+        "#f38ba8",
+        "#eba0ac",
+        "#fab387",
+        "#f9e2af",
+        "#a6e3a1",
+        "#94e2d5",
+        "#89dceb",
+        "#74c7ec",
+        "#89b4fa",
+        "#b4befe"
+    ]
+}

jsonl_cli-0.1.2.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: jsonl-cli
+Version: 0.1.2
+Summary: CLI JSONL viewer
+Requires-Python: >=3.9
+License-File: LICENSE
+Dynamic: license-file

jsonl_cli-0.1.2.dist-info/RECORD

@@ -0,0 +1,19 @@
+jsonl_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jsonl_cli/__main__.py,sha256=0g3iknXOS9gZUcpL_trgAcuCJnZZKjdsT_xt61WOVb4,60
+jsonl_cli/cli.py,sha256=Z6xG9m3WgYDl2GY5EgIiVQ5OttkijSI131Vpz1MU74c,8028
+jsonl_cli/colors.py,sha256=i2MueCV4DeiN5YrHMrbE4DOmooEj-cJcU_2t5YmU8HI,2277
+jsonl_cli/command.py,sha256=C2bCtP9cZUg60uTGyYwBCKSbysEUOqJ95haNhlOTFaU,2550
+jsonl_cli/containers.py,sha256=pL4lvl3xL1NqROkSRJMAzyJCOOrV4FV1j4GbLO_dZF4,746
+jsonl_cli/helpers.py,sha256=VEKxh67Jz7JdnEEiQho2i3EdbL9HHBUz_XJbisyv-Lk,4157
+jsonl_cli/render.py,sha256=rLZ2gnPIuhuZ-gD8zawa6tFLMA0UC03ypw_LUvw0xx0,6115
+jsonl_cli/search.py,sha256=5Nkg5MneYQ-Kg2WCjykNN6ulMkzZtVDjS-mj0qtTHhA,4830
+jsonl_cli/themes/catppuccin-frappe.json,sha256=ku8kYf0HHvHvV3J2IDTzGei_QRmOu5tzRTS5iDeoNnU,295
+jsonl_cli/themes/catppuccin-latte.json,sha256=04iVoT64y_w_EKgQGxKXOroXH2qWlIWnH5FiEtcGuuY,295
+jsonl_cli/themes/catppuccin-macchiato.json,sha256=DPmG4EGNGguZs2AcQcIhm_8qhBljFdhhltG5XzV9Je0,295
+jsonl_cli/themes/catppuccin-mocha.json,sha256=0CDmV9ij9fm7cfHgOEukH6cgUCo4bayPOybXjtQFBCU,295
+jsonl_cli-0.1.2.dist-info/licenses/LICENSE,sha256=Y30pdXmLKUPz4ojQ9BJp9xeobyARUbVPXmzeESeRKM8,1070
+jsonl_cli-0.1.2.dist-info/METADATA,sha256=c5RAzpLajzLkS4njdQMevQUReXVsTF-NvbN1lV94cyE,146
+jsonl_cli-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+jsonl_cli-0.1.2.dist-info/entry_points.txt,sha256=jIy5LWmaZEP1HHkZEzbwKYNGx9uyp8bCSPeUVCoEly4,45
+jsonl_cli-0.1.2.dist-info/top_level.txt,sha256=bggxTPfSYVdpvhkOjw_PCnQGBFCdpDYbXA_xy4I37wo,10
+jsonl_cli-0.1.2.dist-info/RECORD,,

jsonl_cli-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jsonl_cli-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jsonl = jsonl_cli.cli:main

jsonl_cli-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Taehoon Hwang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jsonl_cli-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+jsonl_cli