@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/tui/screens/store.tcss

@@ -0,0 +1,274 @@
+StoreScreen {
+
+    #container {
+        hatch: right $primary 15%;
+        overflow: hidden auto;
+    }
+
+    .instruction-text {
+        text-style: dim italic;
+        padding: 1 2;
+    }
+
+    .heading {
+        margin: 0 0 0 0;
+        padding: 1 1 0 2;
+    }
+    .sponsor-me {
+        padding: 0 1;
+        color: $text 70%;
+        border: tall blank;
+    }
+    Footer {
+        .footer-key--key {
+            background: transparent;
+            padding: 0 1;
+        }
+    }
+
+    DirectoryDisplay {
+        padding: 0 1 0 2;
+        border-bottom: solid $foreground 10%;
+
+
+        CondensedPath {
+            pointer: pointer;
+            width: 100%;
+            color: $text-warning;
+            &:hover {
+                background: $foreground 4%;
+                text-style: underline;
+            }
+        }
+    }
+
+    #title-container {
+        align: center top;
+        dock: top;
+        #title-grid {
+            margin: 0 1;
+            border: block black 20%;
+            background: black 20%;
+            grid-size: 2 1;
+            height: auto;
+            grid-columns: 24 1fr;
+            grid-rows: auto;
+            grid-gutter: 1 2;
+            min-width: 40;
+            Mandelbrot {
+                border: none;
+                height: 100%;
+            }
+        }
+    }
+
+    LoadingIndicator {
+        height: 3;
+    }
+
+    GridSelect {
+        grid-gutter: 0;
+        height: auto;
+        padding: 0;
+        margin: 0 0;
+
+        &.-highlight {
+            background: $panel;
+            border: tall $primary 30%;
+        }
+
+        &:focus * {
+            &.-highlight {
+                background: $panel;
+                border: tall $primary;
+            }
+        }
+
+    }
+
+    GridSelect {
+        margin: 0 1;
+        border: round $secondary 50%;
+        keyline: none
+    }
+
+    Launcher GridSelect {
+        keyline: none;
+        margin: 0;
+        border: none;
+    }
+
+    AgentItem {
+        height: auto;
+        border: tall transparent;
+        padding: 0 1;
+        &:hover {
+            background: $panel;
+        }
+        pointer: pointer;
+
+        Grid {
+            grid-size: 2 1;
+            grid-columns: 1fr auto;
+            height: auto;
+            #type {
+                text-align: right;
+            }
+        }
+        #description {
+            text-style: dim;
+        }
+        #author {
+            text-style: italic;
+            color: $text-secondary;
+        }
+    }
+
+    Launcher {
+        GridSelect {
+            width: 1fr;
+        }
+        &.-empty {
+            LauncherGridSelect {
+                visibility: hidden;
+            }
+        }
+        .no-agents {
+            text-style: dim italic;
+            padding: 1 2;
+        }
+    }
+
+    LauncherItem {
+        height: auto;
+        border: tall transparent;
+        padding: 0 1;
+        &:hover {
+            background: $panel;
+        }
+        pointer: pointer;
+        .digit {
+            width: auto;
+            padding: 0 1 0 0;
+            color: $text-success;
+        }
+        #description {
+            text-style: dim;
+            text-wrap: nowrap;
+            text-overflow: ellipsis;
+        }
+        #author {
+            text-style: italic;
+            color: $text-secondary;
+        }
+    }
+
+}
+
+AgentModal {
+    align: center middle;
+
+    .acp-warning {
+        color: $text-success;
+        margin-left: 1;
+        padding: 0 1;
+        margin-bottom: 1;
+    }
+
+    #container {
+
+        margin: 2 4 1 4;
+        padding: 0 1 0 0;
+        max-width: 100;
+        height: auto;
+        border: thick $primary 20%;
+
+        DescriptionContainer {
+            height: auto;
+            padding: 0 0 0 0;
+            margin: 0 0 1 1;
+            max-height: 20;
+            overflow-y: auto;
+            Markdown {
+                padding: 0 1;
+                MarkdownH1 {
+                    margin: 1 1 1 0
+                }
+            }
+
+            &:focus {
+                background: $primary 7%;
+            }
+        }
+
+        Select {
+            width: 1fr;
+            margin-right: 1;
+        }
+        Checkbox {
+            margin: 0;
+        }
+    }
+    Footer {
+        opacity: 0.0;
+        FooterKey {
+            .footer-key--key {
+                color: $accent !important;
+            }
+        }
+    }
+}
+
+CommandEditModal {
+    align: center middle;
+
+    #container {
+        padding: 1 1 0 1;
+        border: thick $primary 20%;
+        border-title-color: $text;
+        margin: 3 6;
+        height: 1fr;
+        height: auto;
+        max-width: 80;
+
+        .instructions {
+            color: $text-primary;
+            padding: 0 1 1 1;
+        }
+
+        TextArea {
+            height: 6
+        }
+
+        #button-container {
+            padding: 1 1 0 1;
+            width: 1fr;
+            align: right top;
+        }
+    }
+
+}
+
+
+ActionModal {
+    align: center middle;
+    #container {
+        margin: 3 6;
+        height: 1fr;
+        max-height: 48;
+        CommandPane {
+            padding: 1 1;
+            background: black 10%;
+            border: tab $primary;
+            &.-success {
+                border: tab $text-success 70%;
+            }
+            &.-fail {
+                border: tab $text-error 50%;
+            }
+        }
+        Button {
+            width: 100%;
+        }
+    }
+}

package/tui/screens/tool_content_screen.py

@@ -0,0 +1,59 @@
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.content import Content
+from textual.screen import ModalScreen
+from textual import containers
+from textual.widgets import Static
+
+from tui.acp import protocol
+from tui.widgets.tool_call import compose_tool_content
+
+
+class ToolContentScreen(ModalScreen[None]):
+    """Full-screen view of tool call content."""
+
+    BINDINGS = [
+        Binding("escape", "dismiss(None)", "Close", show=False),
+        Binding("q", "dismiss(None)", "Close", show=False),
+    ]
+
+    def __init__(self, tool_call: protocol.ToolCall) -> None:
+        self._tool_call = tool_call
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        tool_call = self._tool_call
+        title = tool_call.get("title", "Tool Content")
+        status = tool_call.get("status", "")
+        header_text = f"🔧 {title}"
+        if status == "failed":
+            header_text += " ✘"
+        elif status == "completed":
+            header_text += " ✔"
+        yield Static(Content(header_text), id="tool-content-header")
+        with containers.VerticalScroll(id="full-tool-content"):
+            content = tool_call.get("content", []) or []
+            yield from compose_tool_content(content, self.app)
+
+    DEFAULT_CSS = """
+    ToolContentScreen {
+        align: center middle;
+        background: $surface 95%;
+    }
+    #tool-content-header {
+        dock: top;
+        width: 100%;
+        padding: 1;
+        background: $panel;
+        text-style: bold;
+        color: $text-primary;
+        height: 3;
+    }
+    #full-tool-content {
+        width: 100%;
+        height: 1fr;
+        padding: 1 2;
+        overflow-y: auto;
+        scrollbar-gutter: stable;
+    }
+    """

package/tui/screens/trace.py

@@ -0,0 +1,317 @@
+"""Trace Screen — structured view of agenttrace spans (replaces /logs)."""
+from __future__ import annotations
+
+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 cdh.trace import get_db_path, get_tracer
+
+
+_ICONS = {
+    "ACP": "⇄",
+    "ACP_EVENT": "📡",
+    "LIFECYCLE": "⚙",
+}
+
+
+def _format_duration(seconds: float | None) -> str:
+    if seconds is None:
+        return ""
+    if seconds < 1:
+        return f"{seconds * 1000:.0f}ms"
+    return f"{seconds:.1f}s"
+
+
+def _truncate(s: str, n: int = 60) -> str:
+    return s[:n] + "…" if len(s) > n else s
+
+
+# ── TraceEntry: a single span widget ───────────────────────────
+
+class TraceEntryClicked(Message):
+    def __init__(self, entry: TraceEntry) -> None:
+        super().__init__()
+        self.entry = entry
+
+
+class TraceEntry(Static):
+    """One trace span row: collapsed = one line, expanded = detail."""
+
+    DEFAULT_CSS = """
+    TraceEntry {
+        height: auto;
+        padding: 0 1;
+    }
+    TraceEntry > .trace-summary {
+        height: 1;
+    }
+    TraceEntry > .trace-summary:hover {
+        background: $panel;
+    }
+    TraceEntry.-selected > .trace-summary {
+        background: $accent;
+        color: $text;
+        text-style: bold;
+    }
+    TraceEntry > .trace-body {
+        height: auto;
+        padding: 0 0 0 4;
+    }
+    TraceEntry.-collapsed > .trace-body {
+        display: none;
+    }
+    """
+
+    expanded: reactive[bool] = reactive(False)
+    selected: reactive[bool] = reactive(False)
+
+    def __init__(self, trace_type: str, func_name: str,
+                 duration: float | None = None,
+                 tags: dict | None = None,
+                 session_id: str | None = None) -> None:
+        super().__init__()
+        self.trace_type = trace_type
+        self.func_name = func_name
+        self._duration = duration
+        self._tags = tags or {}
+        self._session_id = session_id or ""
+
+    def compose(self) -> ComposeResult:
+        yield Static(self._summary_text(), classes="trace-summary")
+        yield Static(self._body_text(), classes="trace-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 "▶"
+        icon = _ICONS.get(self.trace_type, "•")
+        t = Text()
+        t.append(f" {marker} ", style="dim")
+        t.append(f"{icon} ", style="bold")
+        t.append(f"{self.trace_type}  ", style="dim")
+        t.append(self.func_name, style="bold")
+        if self._duration is not None:
+            dur = _format_duration(self._duration)
+            t.append(f"  {dur}", style="italic cyan")
+        return t
+
+    def _body_text(self) -> Text:
+        lines = [f"Type:     {self.trace_type}",
+                 f"Function: {self.func_name}"]
+        if self._session_id:
+            lines.append(f"Session:  {self._session_id}")
+        if self._duration is not None:
+            lines.append(f"Duration: {_format_duration(self._duration)}")
+        if self._tags:
+            lines.append("Tags:")
+            for k, v in self._tags.items():
+                lines.append(f"  {k} = {v}")
+        return Text("\n".join(lines))
+
+    def watch_expanded(self, expanded: bool) -> None:
+        self.set_class(not expanded, "-collapsed")
+        try:
+            self.query_one(".trace-summary", Static).update(self._summary_text())
+        except Exception:
+            pass
+
+    def on_click(self) -> None:
+        self.expanded = not self.expanded
+        self.post_message(TraceEntryClicked(self))
+
+    def watch_selected(self, selected: bool) -> None:
+        self.set_class(selected, "-selected")
+        if selected:
+            self.scroll_visible()
+
+
+# ── TraceScreen ─────────────────────────────────────────────────
+
+class TraceScreen(ModalScreen[None]):
+    """Trace viewer — shows structured agenttrace spans (replaces LogScreen)."""
+
+    BINDINGS = [
+        Binding("escape,f4", "dismiss", "Close"),
+        Binding("down,j", "next_entry", "Next", priority=True),
+        Binding("up,k", "prev_entry", "Prev", priority=True),
+        Binding("enter,space,l", "toggle_current", "Toggle"),
+        Binding("o", "open_current", "Open"),
+        Binding("O", "expand_all", "Open all"),
+        Binding("C", "collapse_all", "Close all"),
+        Binding("r", "refresh", "Refresh"),
+    ]
+
+    DEFAULT_CSS = """
+    TraceScreen {
+        align: center middle;
+    }
+
+    TraceScreen > Vertical {
+        width: 95%;
+        height: 90%;
+        border: thick $primary;
+        background: $surface;
+    }
+
+    TraceScreen #trace-header {
+        height: 1;
+        background: $primary;
+        color: $text;
+        padding: 0 1;
+    }
+
+    TraceScreen #trace-list {
+        height: 1fr;
+        background: $surface;
+    }
+    """
+
+    def __init__(self, session_id: str | None = None) -> None:
+        super().__init__()
+        self._session_id = session_id
+        self._entries: list[TraceEntry] = []
+        self._current_index: int = -1
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Static(id="trace-header")
+            yield VerticalScroll(id="trace-list")
+
+    async def on_mount(self) -> None:
+        self.query_one("#trace-list", VerticalScroll).can_focus = False
+        await self._load_traces()
+
+    async def _load_traces(self) -> None:
+        scroller = self.query_one("#trace-list", VerticalScroll)
+        await scroller.remove_children()
+        self._entries = []
+
+        db_path = get_db_path()
+        if not db_path.exists():
+            msg = "[dim]No traces yet. Start an agent session to collect traces.[/dim]"
+            await scroller.mount(Static(msg))
+            self._refresh_header()
+            return
+
+        try:
+            tracer = get_tracer()
+            traces = tracer.get_traces(limit=500, session_id=self._session_id)
+        except Exception:
+            traces = []
+
+        if not traces:
+            msg = f"[dim]No traces found for session: {self._session_id or '(all)'}[/dim]"
+            await scroller.mount(Static(msg))
+            self._refresh_header()
+            return
+
+        for t in traces:
+            trace_type = t.get("type", "ACP")
+            func_name = t.get("function", "")
+            duration = t.get("duration")
+            tags_data = t.get("tags", {})
+            sid = t.get("session_id", "") or self._session_id or ""
+            entry = TraceEntry(
+                trace_type=trace_type,
+                func_name=func_name,
+                duration=duration,
+                tags=tags_data if isinstance(tags_data, dict) else {},
+                session_id=sid,
+            )
+            self._entries.append(entry)
+
+        await scroller.mount(*self._entries)
+        self._current_index = 0 if self._entries else -1
+        self._apply_selection()
+        self._refresh_header()
+
+    def _refresh_header(self) -> None:
+        total = len(self._entries)
+        sid = self._session_id or "(all sessions)"
+        try:
+            self.query_one("#trace-header", Static).update(
+                f"🔍 Trace — {total} spans  |  Session: {sid}  │  "
+                f"↑↓: nav · ⏎: toggle · r: refresh · F4/Esc close"
+            )
+        except Exception:
+            pass
+
+    def _apply_selection(self) -> None:
+        scroller = self.query_one("#trace-list", VerticalScroll)
+        for i, child in enumerate(scroller.children):
+            if isinstance(child, TraceEntry):
+                child.selected = (i == self._current_index)
+
+    @on(TraceEntryClicked)
+    def on_trace_entry_clicked(self, event: TraceEntryClicked) -> None:
+        scroller = self.query_one("#trace-list", VerticalScroll)
+        for i, child in enumerate(scroller.children):
+            if child is event.entry:
+                self._current_index = i
+                self._apply_selection()
+                return
+
+    def _current_entry(self) -> TraceEntry | None:
+        scroller = self.query_one("#trace-list", VerticalScroll)
+        for i, child in enumerate(scroller.children):
+            if isinstance(child, TraceEntry) and i == self._current_index:
+                return child
+        return None
+
+    # ── Actions ─────────────────────────────────────────────────
+
+    def action_next_entry(self) -> None:
+        count = len(self._entries)
+        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:
+        count = len(self._entries)
+        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:
+        for child in self._get_entries():
+            child.expanded = True
+
+    def action_collapse_all(self) -> None:
+        for child in self._get_entries():
+            child.expanded = False
+
+    async def action_refresh(self) -> None:
+        await self._load_traces()
+        self.app.notify("Trace refreshed", title="Trace")
+
+    def _get_entries(self) -> list[TraceEntry]:
+        scroller = self.query_one("#trace-list", VerticalScroll)
+        return [c for c in scroller.children if isinstance(c, TraceEntry)]