@scemoon/cdh 1.0.6 → 1.0.7

package/tui/screens/diff_screen.py

@@ -1,84 +0,0 @@
-from __future__ import annotations
-
-from textual.app import ComposeResult
-from textual.binding import Binding
-from textual.containers import VerticalScroll
-from textual.screen import ModalScreen
-from textual.widgets import Static
-
-from tui.widgets.diff_view import make_diff
-
-
-class DiffScreen(ModalScreen[None]):
-    """Full-screen view of a file diff.
-
-    Opened when a file is selected from the ModifiedFiles sidebar. Displays
-    the same DiffView widget that ``Conversation.post_diff`` would have mounted
-    inline, but as a dedicated modal screen instead of a conversation block.
-    """
-
-    BINDINGS = [
-        Binding("escape", "dismiss(None)", "Close", show=False, priority=True),
-        Binding("q", "dismiss(None)", "Close", show=False, priority=True),
-    ]
-
-    DEFAULT_CSS = """
-    DiffScreen {
-        background: $surface;
-    }
-
-    #diff-header {
-        dock: top;
-        width: 100%;
-        padding: 1 2;
-        background: $panel;
-        color: $text-primary;
-        text-style: bold;
-        height: 3;
-    }
-
-    #diff-header-meta {
-        color: $text-muted;
-        text-style: none;
-    }
-
-    #diff-scroll {
-        width: 100%;
-        height: 1fr;
-        padding: 0 1 0 1;
-    }
-
-    #diff-scroll > DiffView {
-        width: 100%;
-        height: auto;
-    }
-    """
-
-    def __init__(
-        self,
-        path: str,
-        before: str | None,
-        after: str,
-        *,
-        name: str | None = None,
-        id: str | None = None,
-        classes: str | None = None,
-    ) -> None:
-        super().__init__(name=name, id=id, classes=classes)
-        self._path = path
-        self._before = before
-        self._after = after
-
-    def compose(self) -> ComposeResult:
-        filename = self._path.rsplit("/", 1)[-1] or self._path
-        meta = "untracked" if self._before is None else "modified"
-        yield Static(
-            f"[b]📝 {filename}[/b]  [#888888]{meta}[/]",
-            id="diff-header",
-            markup=True,
-        )
-        with VerticalScroll(id="diff-scroll"):
-            yield make_diff(self._path, self._path, self._before, self._after)
-
-    def on_mount(self) -> None:
-        self.title = f"Diff: {self._path}"

package/tui/screens/log.py

@@ -1,553 +0,0 @@
-"""Log Screen — collapsible per-message view of the JSON-RPC log (F4)."""
-from __future__ import annotations
-
-import json
-import re
-from pathlib import Path
-
-from rich.text import Text
-from textual import on
-from textual.app import ComposeResult
-from textual.binding import Binding
-from textual.containers import Vertical, VerticalScroll
-from textual.message import Message
-from textual.reactive import reactive
-from textual.screen import ModalScreen
-from textual.widgets import Static
-
-from tui.paths import get_log
-
-
-_TAG_RE = re.compile(r"^\[(client|agent|error)\]\s*(.*)$", re.DOTALL)
-_PAGE_SIZE = 50
-
-
-def _find_log_file() -> Path | None:
-    """Return the most recent message log file, or None if empty."""
-    log_dir = get_log() / "messages"
-    if not log_dir.exists():
-        return None
-    candidates = [
-        p for p in log_dir.iterdir()
-        if p.is_file() and p.suffix == ".jsonl" and not p.name.startswith(".")
-    ]
-    if not candidates:
-        return None
-    return max(candidates, key=lambda p: p.stat().st_mtime)
-
-
-# ── JSON syntax highlighting (ANSI) ───────────────────────────────
-
-_ANSI_HIGHLIGHT = re.compile(
-    r'("(?:[^"\\]|\\.)*")(\s*:)?'
-    r'|(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)'
-    r'|\b(true|false|null)\b',
-)
-
-
-def _ansi_repl(m: re.Match) -> str:
-    s, colon, num, lit = m.group(1), m.group(2), m.group(3), m.group(4)
-    if s is not None:
-        if colon:
-            return f"\x1b[36m{s}\x1b[0m{colon}"
-        return f"\x1b[33m{s}\x1b[0m"
-    if num is not None:
-        return f"\x1b[35m{num}\x1b[0m"
-    if lit is not None:
-        return f"\x1b[32m{lit}\x1b[0m"
-    return m.group(0)
-
-
-def _highlight_json(raw: str) -> str:
-    """Return a pretty-printed JSON string with ANSI color escapes."""
-    try:
-        obj = json.loads(raw)
-        formatted = json.dumps(obj, indent=2, ensure_ascii=False)
-    except Exception:
-        return raw
-    return _ANSI_HIGHLIGHT.sub(_ansi_repl, formatted)
-
-
-def _summarize_message_log(record: dict) -> str:
-    """Extract a one-line summary of a MessageLog event record."""
-    event = record.get("event", "")
-    turn = record.get("turn", "")
-    turn_str = f" [dim](turn {turn})[/dim]" if turn != "" else ""
-    if event == "user_input":
-        text = record.get("text", "")
-        return f"user_input  [dim]\"{text[:60]}{'…' if len(text) > 60 else ''}\"[/dim]{turn_str}"
-    if event == "agent_output":
-        text = record.get("text", "")
-        return f"agent_output  [dim]\"{text[:60]}{'…' if len(text) > 60 else ''}\"[/dim]{turn_str}"
-    if event == "agent_thought":
-        return f"agent_thought{turn_str}"
-    if event == "tool_call":
-        name = record.get("tool_name", "")
-        return f"tool_call  [bold]{name}[/bold]{turn_str}"
-    if event == "tool_result":
-        name = record.get("tool_name", "")
-        status = record.get("status", "success")
-        return f"tool_result  [bold]{name}[/bold] → {status}{turn_str}"
-    if event == "turn_end":
-        reason = record.get("stop_reason", "")
-        return f"turn_end  stop={reason}{turn_str}"
-    if event == "error":
-        msg = record.get("message", "")
-        return f"error: {msg[:60]}{turn_str}"
-    return str(record)[:80]
-
-
-def _summarize(tag: str, raw: str) -> str:
-    """Extract a one-line summary of a JSON-RPC or MessageLog message."""
-    try:
-        obj = json.loads(raw)
-    except Exception:
-        return raw[:80]
-    if not isinstance(obj, dict):
-        return str(obj)[:80]
-    # MessageLog event record (event-driven format)
-    if "event" in obj:
-        return _summarize_message_log(obj)
-    # Legacy JSON-RPC wire format
-    if tag == "agent" and "method" in obj:
-        method = obj.get("method", "")
-        params = obj.get("params", {})
-        if isinstance(params, dict):
-            update = params.get("update", {})
-            if isinstance(update, dict):
-                kind = update.get("sessionUpdate", "")
-                if kind:
-                    return f"{method} → {kind}"
-            sid = params.get("sessionId", "")
-            if method == "session/update" and sid:
-                return f"{method}  [dim]({sid[:8]}…)[/dim]"
-        return method
-    if tag == "client":
-        method = obj.get("method", "")
-        params = obj.get("params", {})
-        if isinstance(params, dict):
-            if method == "session/prompt":
-                prompt = params.get("prompt", [])
-                if isinstance(prompt, list) and prompt:
-                    first = prompt[0]
-                    if isinstance(first, dict):
-                        text = first.get("text", "")
-                        return f"{method}  [dim]\"{text[:40]}{'…' if len(text) > 40 else ''}\"[/dim]"
-        return method
-    if "error" in obj:
-        err = obj.get("error", {})
-        return f"error: {err.get('message', '?')}" if isinstance(err, dict) else "error"
-    return obj.get("method", raw[:60])
-
-
-# ── LogEntry: a single collapsible message ────────────────────────
-
-class LogEntryClicked(Message):
-    """Posted when a LogEntry is clicked. Carries the entry reference."""
-
-    def __init__(self, entry: "LogEntry") -> None:
-        super().__init__()
-        self.entry = entry
-
-
-class LogEntry(Static):
-    """One log line: collapsed = summary, expanded = full pretty JSON."""
-
-    DEFAULT_CSS = """
-    LogEntry {
-        height: auto;
-        padding: 0 1;
-    }
-    LogEntry > .log-summary {
-        height: 1;
-    }
-    LogEntry > .log-summary:hover {
-        background: $panel;
-    }
-    LogEntry.-selected > .log-summary {
-        background: $accent;
-        color: $text;
-        text-style: bold;
-    }
-    LogEntry > .log-body {
-        height: auto;
-        padding: 0 0 0 4;
-    }
-    LogEntry.-collapsed > .log-body {
-        display: none;
-    }
-    """
-
-    expanded: reactive[bool] = reactive(False)
-    selected: reactive[bool] = reactive(False)
-
-    def __init__(self, tag: str, raw: str) -> None:
-        super().__init__()
-        self.tag = tag
-        self.raw = raw
-
-    def compose(self) -> ComposeResult:
-        yield Static(self._summary_text(), classes="log-summary")
-        yield Static(self._body_text(), classes="log-body", markup=False)
-
-    def on_mount(self) -> None:
-        self.set_class(not self.expanded, "-collapsed")
-
-    def _summary_text(self) -> Text:
-        marker = "▼" if self.expanded else "▶"
-        if self.tag == "client":
-            style = "bold cyan"
-            tag_label = "[→]"
-        elif self.tag == "agent":
-            style = "bold green"
-            tag_label = "[←]"
-        else:
-            style = "bold red"
-            tag_label = "[!]"
-        t = Text()
-        t.append(f" {marker} ", style="dim")
-        t.append(tag_label, style=style)
-        t.append(" ")
-        # render the summary as markup
-        from rich.markup import render as render_markup
-        try:
-            rendered = render_markup(self._summary_markup())
-            t.append_text(rendered)
-        except Exception:
-            t.append(self._summary_markup())
-        return t
-
-    def _summary_markup(self) -> str:
-        return _summarize(self.tag, self.raw)
-
-    def _body_text(self) -> Text:
-        return Text.from_ansi(_highlight_json(self.raw))
-
-    def watch_expanded(self, expanded: bool) -> None:
-        self.set_class(not expanded, "-collapsed")
-        # Refresh the summary to update the ▼ / ▶ marker
-        try:
-            self.query_one(".log-summary", Static).update(self._summary_text())
-        except Exception:
-            pass
-
-    def on_click(self) -> None:
-        self.expanded = not self.expanded
-        # Notify the screen to update its current_index
-        self.post_message(LogEntryClicked(self))
-
-    def watch_selected(self, selected: bool) -> None:
-        self.set_class(selected, "-selected")
-        if selected:
-            self.scroll_visible()
-
-
-# ── LogScreen ──────────────────────────────────────────────────────
-
-class LogScreen(ModalScreen[None]):
-    """Page-based log viewer (F4). Shows all log entries with 50 per page."""
-
-    BINDINGS = [
-        Binding("escape,f4", "dismiss", "Close"),
-        # Entry navigation within current page
-        Binding("down,j", "next_entry", "Next entry"),
-        Binding("up,k", "prev_entry", "Prev entry"),
-        # Page navigation (log is newest-first, so PageDown = older entries)
-        Binding("pagedown,n", "prev_page", "Prev page", show=False),
-        Binding("pageup,p", "next_page", "Next page", show=False),
-        Binding("home,g", "first_page", "First page", show=False),
-        Binding("end,G", "last_page", "Last page", show=False),
-        # Toggle current
-        Binding("enter,space,l", "toggle_current", "Toggle", show=False),
-        Binding("o", "open_current", "Open", show=False),
-        Binding("O", "expand_all", "Open all"),
-        Binding("C", "collapse_all", "Close all"),
-        # Misc
-        Binding("c", "copy_all", "Copy"),
-    ]
-
-    DEFAULT_CSS = """
-    LogScreen {
-        align: center middle;
-    }
-
-    LogScreen > Vertical {
-        width: 95%;
-        height: 90%;
-        border: thick $primary;
-        background: $surface;
-    }
-
-    LogScreen #log-header {
-        height: 1;
-        background: $primary;
-        color: $text;
-        padding: 0 1;
-    }
-
-    LogScreen #log-list {
-        height: 1fr;
-        background: $surface;
-    }
-    """
-
-    def __init__(self, log_path: Path | None = None) -> None:
-        super().__init__()
-        self._log_path = log_path
-        self._file_pos = 0
-        self._poll_timer: object = None
-        self._entries: list[tuple[str, str]] = []
-        self._current_page: int = 1
-        self._current_index: int = -1
-        self._file_was_present: bool = False
-
-    def compose(self) -> ComposeResult:
-        path = self._log_path or _find_log_file()
-        self._log_path = path
-        with Vertical():
-            yield Static(self._header_text(), id="log-header")
-            yield VerticalScroll(id="log-list")
-
-    async def on_mount(self) -> None:
-        self.query_one("#log-list", VerticalScroll).can_focus = False
-        if self._log_path is None:
-            self._append_system("No log file yet. Start an agent to begin logging.")
-            return
-        if not self._log_path.exists():
-            self._append_system(
-                f"⌛ Waiting for log file to be created…\n   {self._log_path}"
-            )
-            self._poll_timer = self.set_interval(0.2, self._poll_new_lines)
-            return
-        await self._begin_tailing()
-
-    # ── Page helpers ───────────────────────────────────────────────
-
-    def _total_pages(self) -> int:
-        return max(1, (len(self._entries) + _PAGE_SIZE - 1) // _PAGE_SIZE)
-
-    def _page_range(self) -> tuple[int, int]:
-        start = (self._current_page - 1) * _PAGE_SIZE
-        end = min(start + _PAGE_SIZE, len(self._entries))
-        return start, end
-
-    async def _render_page(self) -> None:
-        scroller = self.query_one("#log-list", VerticalScroll)
-        await scroller.remove_children()
-        start, end = self._page_range()
-        page_entries = self._entries[start:end]
-        await scroller.mount(*[LogEntry(tag, raw) for tag, raw in page_entries])
-        self._current_index = 0 if page_entries else -1
-        self._apply_selection()
-        self._refresh_header()
-
-    async def _navigate_to_page(self, page: int) -> None:
-        total = self._total_pages()
-        self._current_page = max(1, min(page, total))
-        await self._render_page()
-
-    # ── File loading ───────────────────────────────────────────────
-
-    async def _begin_tailing(self) -> None:
-        """Read entire log file and start polling."""
-        assert self._log_path is not None
-        try:
-            with self._log_path.open("r", encoding="utf-8", errors="replace") as f:
-                data = f.read()
-            self._file_pos = self._log_path.stat().st_size
-        except OSError as e:
-            self._append_system(f"Failed to open log: {e}")
-            return
-        self._file_was_present = True
-        self._entries = []
-        await self._ingest(data)
-        self._current_page = self._total_pages()
-        await self._render_page()
-        if self._poll_timer is None:
-            self._poll_timer = self.set_interval(0.2, self._poll_new_lines)
-
-    def on_unmount(self) -> None:
-        if self._poll_timer is not None:
-            stop = getattr(self._poll_timer, "stop", None)
-            if callable(stop):
-                stop()
-            self._poll_timer = None
-
-    def _header_text(self) -> str:
-        total = len(self._entries)
-        pages = self._total_pages()
-        start, end = self._page_range()
-        display_start = start + 1 if total > 0 else 0
-        return (
-            f"📋 Session log — Page {self._current_page}/{pages} · "
-            f"Showing {display_start}-{end} of {total} entries  │  "
-            f"↑↓: entry · n/p: page · g/G: first/last · ⏎ toggle · F4/Esc close"
-            if self._log_path
-            else "📋 Session log — (no log file found)"
-        )
-
-    def _refresh_header(self) -> None:
-        try:
-            self.query_one("#log-header", Static).update(self._header_text())
-        except Exception:
-            pass
-
-    def _apply_selection(self) -> None:
-        scroller = self.query_one("#log-list", VerticalScroll)
-        for i, child in enumerate(scroller.children):
-            if isinstance(child, LogEntry):
-                child.selected = (i == self._current_index)
-
-    @on(LogEntryClicked)
-    def on_log_entry_clicked(self, event: LogEntryClicked) -> None:
-        scroller = self.query_one("#log-list", VerticalScroll)
-        for i, child in enumerate(scroller.children):
-            if child is event.entry:
-                self._current_index = i
-                self._apply_selection()
-                return
-
-    def _append_system(self, msg: str) -> None:
-        scroller = self.query_one("#log-list", VerticalScroll)
-        scroller.mount(Static(f"[dim]{msg}[/dim]"))
-
-    # ── Polling for new lines ──────────────────────────────────────
-
-    async def _poll_new_lines(self) -> None:
-        if self._log_path is None:
-            return
-        if not self._log_path.exists():
-            return
-        if not self._file_was_present:
-            self._append_system(f"── log file appeared: {self._log_path} ──")
-            await self._begin_tailing()
-            return
-        try:
-            size = self._log_path.stat().st_size
-            if size < self._file_pos:
-                self._file_pos = 0
-            if size == self._file_pos:
-                return
-            with self._log_path.open("r", encoding="utf-8", errors="replace") as f:
-                f.seek(self._file_pos)
-                new_text = f.read()
-            self._file_pos = size
-            if new_text:
-                await self._ingest(new_text)
-        except OSError:
-            pass
-
-    async def _ingest(self, chunk: str) -> None:
-        was_on_last_page = (
-            len(self._entries) == 0
-            or self._current_page == self._total_pages()
-        )
-        for line in chunk.splitlines():
-            if not line.strip():
-                continue
-            try:
-                record = json.loads(line)
-                if isinstance(record, dict) and "event" in record:
-                    event = record.get("event", "")
-                    if event in ("user_input",):
-                        tag = "client"
-                    elif event in ("agent_output", "agent_thought", "tool_call", "tool_result", "turn_end"):
-                        tag = "agent"
-                    else:
-                        tag = "error"
-                    self._entries.append((tag, line))
-                    continue
-            except (json.JSONDecodeError, ValueError):
-                pass
-            m = _TAG_RE.match(line)
-            if m:
-                self._entries.append((m.group(1), m.group(2)))
-            else:
-                self._entries.append(("error", line))
-        if was_on_last_page:
-            self._current_page = self._total_pages()
-            await self._render_page()
-        else:
-            self._refresh_header()
-
-    # ── Actions ────────────────────────────────────────────────────
-
-    def _current_entry(self) -> LogEntry | None:
-        scroller = self.query_one("#log-list", VerticalScroll)
-        for i, child in enumerate(scroller.children):
-            if isinstance(child, LogEntry) and i == self._current_index:
-                return child
-        return None
-
-    async def action_next_page(self) -> None:
-        if self._current_page < self._total_pages():
-            await self._navigate_to_page(self._current_page + 1)
-
-    async def action_prev_page(self) -> None:
-        if self._current_page > 1:
-            await self._navigate_to_page(self._current_page - 1)
-
-    async def action_first_page(self) -> None:
-        await self._navigate_to_page(1)
-
-    async def action_last_page(self) -> None:
-        await self._navigate_to_page(self._total_pages())
-
-    def action_next_entry(self) -> None:
-        scroller = self.query_one("#log-list", VerticalScroll)
-        count = sum(1 for c in scroller.children if isinstance(c, LogEntry))
-        if count == 0:
-            return
-        if self._current_index < 0:
-            self._current_index = 0
-        else:
-            self._current_index = min(count - 1, self._current_index + 1)
-        self._apply_selection()
-
-    def action_prev_entry(self) -> None:
-        scroller = self.query_one("#log-list", VerticalScroll)
-        count = sum(1 for c in scroller.children if isinstance(c, LogEntry))
-        if count == 0:
-            return
-        if self._current_index < 0:
-            self._current_index = count - 1
-        else:
-            self._current_index = max(0, self._current_index - 1)
-        self._apply_selection()
-
-    def action_toggle_current(self) -> None:
-        entry = self._current_entry()
-        if entry is not None:
-            entry.expanded = not entry.expanded
-
-    def action_open_current(self) -> None:
-        entry = self._current_entry()
-        if entry is not None:
-            entry.expanded = True
-
-    def action_expand_all(self) -> None:
-        scroller = self.query_one("#log-list", VerticalScroll)
-        for child in scroller.children:
-            if isinstance(child, LogEntry):
-                child.expanded = True
-
-    def action_collapse_all(self) -> None:
-        scroller = self.query_one("#log-list", VerticalScroll)
-        for child in scroller.children:
-            if isinstance(child, LogEntry):
-                child.expanded = False
-
-    def action_copy_all(self) -> None:
-        try:
-            import pyperclip
-        except ImportError:
-            self.app.notify("pyperclip not installed", title="Log", severity="warning")
-            return
-        if self._log_path is None:
-            return
-        try:
-            text = self._log_path.read_text(errors="replace")
-            pyperclip.copy(text)
-            self.app.notify("Log copied to clipboard", title="Log")
-        except Exception as e:
-            self.app.notify(f"Copy failed: {e}", title="Log", severity="error")