handoff-cli 0.3.0__py3-none-any.whl

cli/jsonl_parser.py

@@ -0,0 +1,182 @@
+"""Shared JSONL parsing and formatting helpers."""
+
+from __future__ import annotations
+
+import datetime
+import json
+from dataclasses import dataclass
+from typing import TextIO
+
+
+@dataclass
+class ParsedEvent:
+    """One parsed event extracted from a JSONL line."""
+
+    ts: str
+    text: str
+    kind: str
+
+
+def _extract_time(obj: dict) -> str:
+    ts_str = obj.get("timestamp", "")
+    if ts_str and isinstance(ts_str, str):
+        try:
+            dt = datetime.datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+            # Convert to local timezone (ISO timestamps from Claude are UTC)
+            if dt.tzinfo is not None:
+                dt = dt.astimezone()
+            return dt.strftime("%H:%M:%S")
+        except (ValueError, TypeError):
+            pass
+    return ""
+
+
+def _collapse_whitespace(text: str) -> str:
+    return " ".join(text.split())
+
+
+def _truncate(text: str, n: int = 80) -> str:
+    collapsed = _collapse_whitespace(text)
+    if len(collapsed) <= n:
+        return collapsed
+    return collapsed[: n - 1] + "…"
+
+
+def _short_tool_id(tool_id: str) -> str:
+    if "_" in tool_id:
+        return tool_id.split("_")[-1][:8]
+    return tool_id[:8]
+
+
+def parse_jsonl_line(line: str, prev_ts: str = "") -> list[ParsedEvent]:
+    """Parse one JSONL line into zero or more logical events."""
+    line = line.strip()
+    if not line.startswith("{"):
+        return []
+
+    try:
+        obj = json.loads(line)
+    except json.JSONDecodeError:
+        return []
+
+    ts = _extract_time(obj) or prev_ts
+    t = obj.get("type", "")
+    events: list[ParsedEvent] = []
+
+    if t == "stream_event":
+        se = obj.get("event", {})
+        et = se.get("type", "")
+        if et == "content_block_start":
+            cb = se.get("content_block", {})
+            if cb.get("type") == "tool_use":
+                name = cb.get("name", "?")
+                tool_id = cb.get("id", "")
+                events.append(ParsedEvent(ts, f"{name} {_short_tool_id(tool_id)}", "tool"))
+        elif et == "message_start":
+            model = se.get("message", {}).get("model", "")
+            if model:
+                events.append(ParsedEvent(ts, f"model: {model}", "info"))
+
+    elif t == "assistant":
+        for content in obj.get("message", {}).get("content", []):
+            ct = content.get("type", "")
+            if ct == "text":
+                text = content.get("text", "")
+                if isinstance(text, str) and text.strip():
+                    events.append(ParsedEvent(ts, text, "text"))
+            elif ct == "tool_use":
+                name = content.get("name", "?")
+                tool_id = content.get("id", "")
+                events.append(ParsedEvent(ts, f"{name} {_short_tool_id(tool_id)}", "tool"))
+
+    elif t == "user":
+        content = obj.get("message", {}).get("content", [])
+        if isinstance(content, list):
+            for item in content:
+                if isinstance(item, dict) and item.get("type") == "tool_result":
+                    result = item.get("content", "")
+                    if isinstance(result, str) and result.strip():
+                        events.append(ParsedEvent(ts, result, "info"))
+
+    elif t == "system":
+        subtype = obj.get("subtype", "")
+        if subtype == "status":
+            status = obj.get("status", "")
+            if status:
+                events.append(ParsedEvent(ts, f"status: {status}", "info"))
+        elif subtype == "task_started":
+            desc = obj.get("description", "")
+            if desc:
+                events.append(ParsedEvent(ts, desc, "task"))
+
+    elif t == "result":
+        subtype = obj.get("subtype", "")
+        is_success = subtype == "success" and not obj.get("is_error", False)
+        duration = obj.get("duration_ms", 0)
+        cost = obj.get("total_cost_usd", 0)
+        turns = obj.get("num_turns", 0)
+        dur_str = f"{duration / 1000:.0f}s" if duration else "?"
+        summary = f"Done  {dur_str}  {turns} turns  ${cost:.4f}"
+        if is_success:
+            events.append(ParsedEvent(ts, summary, "result"))
+        else:
+            events.append(ParsedEvent(ts, f"ERROR: {summary}", "error"))
+
+        result_text = obj.get("result", "")
+        if isinstance(result_text, str) and result_text:
+            result_kind = "result_text" if is_success else "error_text"
+            events.append(ParsedEvent(ts, result_text, result_kind))
+
+    return events
+
+
+def read_events(handle: TextIO, prev_ts: str = "") -> tuple[list[ParsedEvent], str]:
+    """Read all remaining lines from a file handle into parsed events."""
+    last_ts = prev_ts
+    events: list[ParsedEvent] = []
+    for line in handle:
+        parsed = parse_jsonl_line(line, last_ts)
+        for event in parsed:
+            if event.ts:
+                last_ts = event.ts
+            events.append(event)
+    return events, last_ts
+
+
+def format_event_for_viewer(event: ParsedEvent) -> str | None:
+    """Format one parsed event into a compact list-view line."""
+    if event.kind == "result_text":
+        return None
+
+    ts = event.ts or " " * 8
+    kind_mark = {
+        "tool": "▷",
+        "text": "✎",
+        "result": "✓",
+        "error": "✗",
+        "task": "▶",
+        "info": "·",
+    }.get(event.kind, " ")
+    return f"`{ts}` {kind_mark} {_truncate(event.text)}"
+
+
+def format_event_for_stream(event: ParsedEvent) -> str | None:
+    """Return the single-line text stream shown during `handoff run`."""
+    if event.kind != "text":
+        return None
+    text = _collapse_whitespace(event.text)
+    return text or None
+
+
+def extract_result(jsonl_path: str) -> str | None:
+    """Return the last successful result text from a JSONL file."""
+    try:
+        with open(jsonl_path, "r") as handle:
+            last_result = None
+            events, _ = read_events(handle)
+            for event in events:
+                if event.kind == "result_text":
+                    last_result = event.text
+            return last_result
+    except FileNotFoundError:
+        return None

cli/jsonl_viewer.py

@@ -0,0 +1,440 @@
+"""Shared JSONL viewer for handoff list (detail) and tail commands.
+
+Uses Textual to render Claude stream-json output: compact progress log,
+input prompt (markdown), and final result (markdown). No external cclean dependency.
+
+Modes:
+  - static:  list detail page; Escape dismisses back to list
+  - follow:  `handoff tail`; Escape / Q exit the app
+"""
+
+from __future__ import annotations
+
+import os
+import asyncio
+from typing import Optional
+
+from textual import work
+from textual.app import App, ComposeResult
+from textual.screen import Screen
+from textual.widgets import (
+    Footer,
+    TabbedContent,
+    TabPane,
+    Static,
+)
+from textual.containers import VerticalScroll
+from textual.binding import Binding
+from .jsonl_parser import ParsedEvent, format_event_for_viewer, read_events
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# JsonlViewerScreen
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class JsonlViewerScreen(Screen):
+    """Shared JSONL viewer screen for handoff list (detail) and tail.
+
+    Layout:
+      - RunInfoBar (top bar)
+      - TabbedContent (Stream / Prompt / Result)
+      - Footer (key bindings)
+    """
+
+    BINDINGS = [
+        Binding("escape,left", "back", "Back", show=True),
+        Binding("o", "go_resume", "Open in Claude", show=True),
+        Binding("c", "copy_session", "Copy Session", show=True),
+        Binding("q", "quit", "Quit", show=True),
+        Binding("1", "show_tab('stream')", "Stream", show=True),
+        Binding("2", "show_tab('output')", "Output", show=True),
+        Binding("3", "show_tab('prompt')", "Prompt", show=True),
+        Binding("4", "show_tab('result')", "Result", show=True),
+        Binding("up,k", "scroll_active('up')", "Scroll up", show=False),
+        Binding("down,j", "scroll_active('down')", "Scroll down", show=False),
+        Binding("pageup", "scroll_active('page_up')", "Page up", show=False),
+        Binding("pagedown", "scroll_active('page_down')", "Page down", show=False),
+        Binding("home", "scroll_active('home')", "Top", show=False),
+        Binding("end", "scroll_active('end')", "Bottom", show=False),
+    ]
+
+    def __init__(
+        self,
+        jsonl_path: str,
+        prompt_path: str,
+        out_path: str,
+        result_path: str,
+        run_info: dict,
+        mode: str = "static",
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ):
+        # Store parameters before super().__init__
+        self._jl_path = jsonl_path
+        self._p_path = prompt_path
+        self._o_path = out_path
+        self._r_path = result_path
+        self._r_info = run_info
+        self._mode = mode
+        self._last_ts = ""
+        self._fpos = 0
+        self._out_fpos = 0
+        self._result_text: Optional[str] = None
+        self._stream_raw = ""      # accumulated stream content for incremental update
+        self._out_raw = ""         # accumulated .out.txt content
+        self._last_stream_line = ""
+        self._poll_interval = 0.5
+        # Auto-follow state
+        self._auto_follow = {"stream": True, "output": True}
+        self._pending_new_count = {"stream": 0, "output": 0}
+        self._keep_polling = True
+        super().__init__(name=name, id=id, classes=classes)
+
+    def compose(self) -> ComposeResult:
+        ri = self._r_info
+        yield Static(
+            f"Run: {ri.get('run_id', '?')}  ·  "
+            f"{ri.get('date', '?')}  ·  "
+            f"cwd: {ri.get('cwd', '?')}",
+            id="info_bar",
+        )
+        with TabbedContent(initial="stream"):
+            with TabPane("Stream JSONL", id="stream"):
+                with VerticalScroll(id="stream_scroll"):
+                    yield Static("Loading…", id="stream_text", markup=False)
+            with TabPane("Output .out", id="output"):
+                with VerticalScroll(id="output_scroll"):
+                    yield Static("Loading…", id="output_text", markup=False)
+            with TabPane("Prompt", id="prompt"):
+                with VerticalScroll(id="prompt_scroll"):
+                    yield Static("", id="prompt_text", markup=False)
+            with TabPane("Result", id="result"):
+                with VerticalScroll(id="result_scroll"):
+                    yield Static("", id="result_text", markup=False)
+        yield Footer()
+
+    def on_mount(self) -> None:
+        # Load prompt text
+        if os.path.isfile(self._p_path):
+            try:
+                with open(self._p_path, "r", encoding="utf-8", errors="replace") as f:
+                    pt = f.read().strip()
+                if pt:
+                    self.query_one("#prompt_text", Static).update(
+                        self._text_with_path("Prompt", self._p_path, pt)
+                    )
+            except (OSError, UnicodeDecodeError):
+                pass
+        else:
+            self.query_one("#prompt_text", Static).update(self._text_with_path("Prompt", self._p_path, ""))
+
+        # Load result text
+        if os.path.isfile(self._r_path):
+            try:
+                with open(self._r_path, "r", encoding="utf-8", errors="replace") as f:
+                    rt = f.read().strip()
+                if rt:
+                    self._result_text = rt
+                    self.query_one("#result_text", Static).update(
+                        self._text_with_path("Result", self._r_path, rt)
+                    )
+            except (OSError, UnicodeDecodeError):
+                pass
+        else:
+            self.query_one("#result_text", Static).update(self._text_with_path("Result", self._r_path, ""))
+
+        # Load JSONL stream.
+        self._stream_raw = self._header_line("JSONL", self._jl_path)
+        self.query_one("#stream_text", Static).update(self._stream_raw)
+        if os.path.isfile(self._jl_path):
+            with open(self._jl_path, "r", encoding="utf-8", errors="replace") as f:
+                f.seek(self._fpos)
+                events, self._last_ts = read_events(f, self._last_ts)
+                self._fpos = f.tell()
+            self._append_events(events)
+
+        self._out_raw = self._header_line("Output", self._o_path)
+        self.query_one("#output_text", Static).update(self._out_raw)
+        self._append_output_from_file()
+
+        # Scroll to bottom after initial load
+        self._scroll_to_bottom("stream")
+        self._scroll_to_bottom("output")
+
+        # Start poll worker for all modes (live updates for running runs)
+        self._poll_jsonl()
+
+    # ── follow worker ────────────────────────────────────────────────────
+
+    @work(exclusive=True, thread=False)
+    async def _poll_jsonl(self) -> None:
+        while self._keep_polling:
+            if os.path.isfile(self._jl_path):
+                try:
+                    with open(self._jl_path, "r", encoding="utf-8", errors="replace") as f:
+                        f.seek(self._fpos)
+                        events, self._last_ts = read_events(f, self._last_ts)
+                        self._fpos = f.tell()
+                    self._append_events(events)
+                except (OSError, UnicodeDecodeError):
+                    pass
+
+            self._append_output_from_file()
+
+            # Check scroll position to update auto-follow state
+            self._sync_auto_follow("stream")
+            self._sync_auto_follow("output")
+
+            await asyncio.sleep(self._poll_interval)
+
+    def on_unmount(self) -> None:
+        """Ensure poll loop exits when screen is removed."""
+        self._keep_polling = False
+
+    def _sync_auto_follow(self, tab_id: str) -> None:
+        """Update _auto_follow based on current scroll position."""
+        try:
+            scroll = self.query_one(f"#{tab_id}_scroll", VerticalScroll)
+            self._auto_follow[tab_id] = scroll.is_vertical_scroll_end
+        except Exception:
+            pass
+
+    def _scroll_to_bottom(self, tab_id: str) -> None:
+        """Scroll stream container to bottom."""
+        try:
+            self.query_one(f"#{tab_id}_scroll", VerticalScroll).scroll_end(animate=False)
+        except Exception:
+            pass
+
+    def _update_info_bar(self) -> None:
+        """Update info bar with auto-follow status."""
+        try:
+            ri = self._r_info
+            parts = [
+                f"Run: {ri.get('run_id', '?')}",
+                ri.get("date", "?"),
+                f"cwd: {ri.get('cwd', '?')}",
+            ]
+            status_parts = []
+            for tab_id, label in (("stream", "stream"), ("output", "output")):
+                if self._auto_follow[tab_id]:
+                    status_parts.append(f"{label}: follow")
+                elif self._pending_new_count[tab_id]:
+                    status_parts.append(f"{label}: {self._pending_new_count[tab_id]} new")
+                else:
+                    status_parts.append(f"{label}: paused")
+            parts.append(" | ".join(status_parts))
+            self.query_one("#info_bar", Static).update("  ·  ".join(parts))
+        except Exception:
+            pass
+
+    def _header_line(self, label: str, path: str) -> str:
+        return f"{label}: {os.path.abspath(os.path.expanduser(path))}"
+
+    def _text_with_path(self, label: str, path: str, body: str) -> str:
+        header = self._header_line(label, path)
+        return f"{header}\n\n{body}" if body else header
+
+    def _append_text_block(self, tab_id: str, text: str) -> None:
+        if not text:
+            return
+        self._sync_auto_follow(tab_id)
+        attr = "_stream_raw" if tab_id == "stream" else "_out_raw"
+        widget_id = "#stream_text" if tab_id == "stream" else "#output_text"
+        current = getattr(self, attr) or ""
+        updated = current + text if current.endswith("\n") or text.startswith("\n") else current + "\n" + text
+        setattr(self, attr, updated)
+        try:
+            self.query_one(widget_id, Static).update(updated)
+        except Exception:
+            return
+
+        new_count = text.count("\n") + (0 if text.endswith("\n") else 1)
+        if self._auto_follow[tab_id]:
+            self._scroll_to_bottom(tab_id)
+            self._pending_new_count[tab_id] = 0
+        else:
+            self._pending_new_count[tab_id] += max(new_count, 1)
+        self._update_info_bar()
+
+    def _append_output_from_file(self) -> None:
+        if not os.path.isfile(self._o_path):
+            return
+        try:
+            size = os.path.getsize(self._o_path)
+            if size < self._out_fpos:
+                self._out_fpos = 0
+            with open(self._o_path, "r", encoding="utf-8", errors="replace") as f:
+                f.seek(self._out_fpos)
+                chunk = f.read()
+                self._out_fpos = f.tell()
+        except OSError:
+            return
+        self._append_text_block("output", chunk)
+
+    def _append_events(self, events: list[ParsedEvent]) -> None:
+        if not events:
+            return
+
+        new_lines: list[str] = []
+        for event in events:
+            if event.kind in ("result_text", "error_text"):
+                self._result_text = event.text
+                try:
+                    self.query_one("#result_text", Static).update(
+                        self._text_with_path("Result", self._r_path, self._result_text)
+                    )
+                    self.query_one(TabbedContent).active = "result"
+                except Exception:
+                    pass
+                continue
+
+            line = format_event_for_viewer(event)
+            if line and line != self._last_stream_line:
+                new_lines.append(line)
+                self._last_stream_line = line
+
+        if not new_lines:
+            return
+
+        # Check if we should auto-follow before updating content
+        self._sync_auto_follow("stream")
+
+        try:
+            current = self._stream_raw or ""
+            appended = "\n".join(new_lines)
+            self._stream_raw = current + "\n" + appended if current else appended
+            self.query_one("#stream_text", Static).update(self._stream_raw)
+        except Exception:
+            return
+
+        # Auto-scroll or track pending new content
+        if self._auto_follow["stream"]:
+            self._scroll_to_bottom("stream")
+            self._pending_new_count["stream"] = 0
+        else:
+            self._pending_new_count["stream"] += len(new_lines)
+
+        self._update_info_bar()
+
+    # ── actions ──────────────────────────────────────────────────────────
+
+    def action_back(self) -> None:
+        self._keep_polling = False
+        if self._mode == "static":
+            self.dismiss()
+        else:
+            self.app.exit()
+
+    def action_go_resume(self) -> None:
+        self._keep_polling = False
+        rid = self._r_info.get("run_id", "")
+        if hasattr(self.app, "_action_result"):
+            self.app._action_result = f"resume:{rid}"
+        self.app.exit()
+
+    def action_copy_session(self) -> None:
+        import subprocess
+        uid = self._r_info.get("uuid", "")
+        if uid:
+            try:
+                subprocess.run(["pbcopy"], input=uid, text=True, check=True)
+                self.notify(f"Copied: {uid}", severity="information", timeout=3)
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                self.notify("Copy failed: pbcopy not available", severity="error")
+
+    def action_quit(self) -> None:
+        self._keep_polling = False
+        self.app.exit()
+
+    def action_show_tab(self, tab_id: str) -> None:
+        try:
+            self.query_one(TabbedContent).active = tab_id
+        except Exception:
+            pass
+
+    def action_scroll_active(self, direction: str) -> None:
+        try:
+            active = self.query_one(TabbedContent).active
+            scroll = self.query_one(f"#{active}_scroll", VerticalScroll)
+        except Exception:
+            return
+
+        if direction == "up":
+            scroll.scroll_up(animate=False)
+        elif direction == "down":
+            scroll.scroll_down(animate=False)
+        elif direction == "page_up":
+            scroll.scroll_page_up(animate=False)
+        elif direction == "page_down":
+            scroll.scroll_page_down(animate=False)
+        elif direction == "home":
+            scroll.scroll_home(animate=False)
+        elif direction == "end":
+            scroll.scroll_end(animate=False)
+
+        if active in self._auto_follow:
+            self._sync_auto_follow(active)
+            if self._auto_follow[active]:
+                self._pending_new_count[active] = 0
+            self._update_info_bar()
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Tail entry point
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class JsonlTailApp(App):
+    """Standalone Textual app for `handoff tail`."""
+
+    TITLE = "handoff tail"
+
+    def __init__(
+        self,
+        jsonl_path: str,
+        prompt_path: str,
+        out_path: str,
+        result_path: str,
+        run_info: dict,
+    ):
+        self._a_jl = jsonl_path
+        self._a_pp = prompt_path
+        self._a_op = out_path
+        self._a_rp = result_path
+        self._a_ri = run_info
+        super().__init__()
+
+    def on_mount(self) -> None:
+        self.push_screen(JsonlViewerScreen(
+            jsonl_path=self._a_jl,
+            prompt_path=self._a_pp,
+            out_path=self._a_op,
+            result_path=self._a_rp,
+            run_info=self._a_ri,
+            mode="follow",
+        ))
+
+
+def run_tail(jsonl_path: str, prompt_path: str, result_path: str, run_info: dict) -> None:
+    """Entry point for `handoff tail`."""
+    out_path = run_info.get("out_path", "")
+    JsonlTailApp(jsonl_path, prompt_path, out_path, result_path, run_info).run(mouse=False)
+
+
+def make_viewer_screen(
+    jsonl_path: str,
+    prompt_path: str,
+    out_path: str,
+    result_path: str,
+    run_info: dict,
+) -> JsonlViewerScreen:
+    """Create a viewer screen for embedding in another Textual app (list detail)."""
+    return JsonlViewerScreen(
+        jsonl_path=jsonl_path,
+        prompt_path=prompt_path,
+        out_path=out_path,
+        result_path=result_path,
+        run_info=run_info,
+        mode="static",
+    )