iCode-TUI 0.29.1__py3-none-any.whl

chrys/app/tui/widgets/trajectory/timeline.py

@@ -0,0 +1,380 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""The trajectory dashboard's Timeline page: one turn's operations on a time axis, or as a dependency graph."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+
+from rich.cells import cell_len
+from rich.style import Style
+from rich.text import Text
+from textual.color import Color, ColorParseError
+
+from chrys.app.tui.util.rich_style import rich_style_from_textual_color
+from chrys.app.tui.widgets.trajectory.chartkit import (
+    fit_cells,
+    fit_text_cells,
+    time_ruler,
+    timeline_bar,
+    unresolved_bar,
+)
+from chrys.app.tui.widgets.trajectory.presentation import (
+    ELAPSED_SCOPE,
+    PRECISION_SYMBOLS,
+    TIME_RULER,
+    TURN_LABEL,
+    WIDE_MIN_COLUMNS,
+    DashboardLook,
+    RenderContext,
+    fit_text_right,
+    format_duration,
+    identity_with_hook_id,
+    metric_value,
+    precision_badge,
+    precision_label,
+    precision_style,
+    section_style,
+)
+from chrys.foundation.i18n import msg
+from chrys.service.analytics import FLOW_TERMINAL_INDEX, Metric, Precision, TimelineOperation, TurnAnalysis
+
+_GRAPH_LEGEND = msg(
+    "tui.trajectory.graph.legend",
+    fallback="│ parent · ⇠ causal · ┄ adjacent only (no proven dependency)",
+)
+_GRAPH_TITLE = msg("tui.trajectory.graph.title", fallback="Dependency graph · turn {turn}")
+_GRAPH_RESPONSE = msg("tui.trajectory.graph.response", fallback="response")
+_GRAPH_NONE = msg(
+    "tui.trajectory.graph.none",
+    fallback="No dependency graph is available for this turn.",
+)
+_GRAPH_CYCLE_WARNING = msg(
+    "tui.trajectory.graph.cycle",
+    fallback="The dependency graph contains a cycle; rows fall back to first-occurrence order.",
+)
+_GRAPH_HINT = msg("tui.trajectory.timeline.graph_hint", fallback="Space: dependency graph")
+_TIMELINE_HINT = msg("tui.trajectory.graph.timeline_hint", fallback="Space: timeline")
+_CATEGORY_MODEL = msg("tui.trajectory.category.model", fallback="Model")
+_CATEGORY_TOOL = msg("tui.trajectory.category.tool", fallback="Tool")
+_CATEGORY_WAIT = msg("tui.trajectory.category.wait", fallback="Wait")
+_CATEGORY_HOOK = msg("tui.trajectory.category.hook", fallback="Hook")
+_CATEGORY_AGENT = msg("tui.trajectory.category.agent", fallback="Agent")
+_CATEGORY_PREPARATION = msg("tui.trajectory.category.preparation", fallback="Prepare")
+_CATEGORY_COMPACTION = msg("tui.trajectory.category.compaction", fallback="Compact")
+_CATEGORY_APPROVAL = msg("tui.trajectory.category.approval", fallback="Approval")
+_CATEGORY_RETRY = msg("tui.trajectory.category.retry", fallback="Retry")
+_CATEGORY_OPERATION = msg("tui.trajectory.category.operation", fallback="Operation")
+
+_OPERATION_CATEGORY_WIDTH = 8
+_OPERATION_CATEGORY_SEPARATOR = " "
+_TIMELINE_LABEL_WIDTH = 27
+_TIMELINE_WIDE_LABEL_WIDTH = 39
+
+
+def timeline_lines(look: DashboardLook, context: RenderContext, turn: TurnAnalysis) -> list[Text]:
+    title = look.message(TURN_LABEL.bind(turn=turn.turn_number or "—"))
+    lines = [
+        Text.assemble(
+            Text(title, style=section_style(look)),
+            Text("  "),
+            _metric_text(look, turn.elapsed_ns),
+            Text(f"  {look.message(_GRAPH_HINT.bind())}", style="dim"),
+        )
+    ]
+    width = context.width
+    category_width = _OPERATION_CATEGORY_WIDTH
+    suffix_reserve = 20
+    # Below the narrowest fitting layout the timeline draws on a fixed
+    # 92-cell canvas and scrolls horizontally instead of squeezing its
+    # columns into illegibility; the Timeline view owns a horizontal
+    # scrollbar, unlike Overview.
+    minimum_fit_width = category_width + _TIMELINE_LABEL_WIDTH + suffix_reserve + 4 + 12
+    canvas_width = width if width >= minimum_fit_width else max(width, 92)
+    label_width = _TIMELINE_WIDE_LABEL_WIDTH if canvas_width >= WIDE_MIN_COLUMNS else _TIMELINE_LABEL_WIDTH
+    # The duration column hugs its widest value so the bars run right up
+    # to the figures instead of leaving a gutter of reserved cells.
+    resolved_suffixes = [
+        format_duration(operation.duration_ns or 0)
+        for operation in turn.operations
+        if operation.start_ns is not None and operation.end_ns is not None
+    ]
+    unresolved_suffixes = [
+        f"{PRECISION_SYMBOLS[operation.precision]} {precision_label(look, operation.precision)}"
+        for operation in turn.operations
+        if operation.start_ns is None or operation.end_ns is None
+    ]
+    suffix_width = min(
+        suffix_reserve,
+        max([8, *(cell_len(suffix) for suffix in (*resolved_suffixes, *unresolved_suffixes))]),
+    )
+    bar_width = max(12, canvas_width - category_width - label_width - suffix_width - 4)
+    prefix_width = category_width + label_width + 3
+    span = max(0, turn.axis_end_ns - turn.axis_start_ns)
+    ruler = time_ruler(span, width=bar_width)
+    ruler.stylize("dim")
+    lines.append(
+        Text.assemble(
+            Text(fit_cells(look.message(TIME_RULER.bind()), prefix_width), style="dim"),
+            ruler,
+        )
+    )
+    for row_index, operation in enumerate(turn.operations):
+        category = _operation_category(look, operation)
+        identity = _operation_identity(look, operation)
+        operation_style = _operation_style(look, operation.family)
+        bar_style = _operation_bar_style(look, operation.family)
+        indented = Text.assemble(
+            Text("│ " * operation.depth, style="dim"),
+            Text(identity, style="dim"),
+        )
+        if operation.start_ns is None or operation.end_ns is None:
+            bar = unresolved_bar(bar_width, style=precision_style(look, operation.precision))
+            suffix = Text.assemble(
+                precision_badge(look, operation.precision),
+                Text(
+                    f" {precision_label(look, operation.precision)}",
+                    style=precision_style(look, operation.precision),
+                ),
+            )
+        else:
+            bar = timeline_bar(
+                operation.start_ns,
+                operation.end_ns,
+                origin=turn.axis_start_ns,
+                span=span,
+                width=bar_width,
+                glyph=_operation_glyph(operation.family),
+                style=bar_style,
+            )
+            suffix = Text(format_duration(operation.duration_ns or 0), style="dim")
+        line = Text.assemble(
+            fit_text_cells(Text(category, style=operation_style), category_width),
+            Text(_OPERATION_CATEGORY_SEPARATOR),
+            fit_text_cells(indented, label_width),
+            Text(" "),
+            bar,
+            Text("  "),
+            fit_text_right(suffix, suffix_width),
+        )
+        if row_index % 2:
+            line.stylize(_zebra_style(look), 0, len(line))
+        lines.append(line)
+    lines.extend([Text(), Text(look.message(ELAPSED_SCOPE.bind()), style="dim")])
+    return lines
+
+
+def dependency_graph_lines(look: DashboardLook, turn: TurnAnalysis) -> list[Text]:
+    lines = [
+        Text.assemble(
+            Text(
+                look.message(_GRAPH_TITLE.bind(turn=turn.turn_number or "—")),
+                style=section_style(look),
+            ),
+            Text(f"  {look.message(_TIMELINE_HINT.bind())}", style="dim"),
+        ),
+        Text(look.message(_GRAPH_LEGEND.bind()), style="dim"),
+        Text(),
+    ]
+    flow = turn.flow
+    if flow is None:
+        lines.append(Text(look.message(_GRAPH_NONE.bind()), style="dim"))
+        return lines
+    if not flow.acyclic:
+        lines.append(
+            Text(
+                look.message(_GRAPH_CYCLE_WARNING.bind()),
+                style=precision_style(look, Precision.UNRESOLVED),
+            )
+        )
+        lines.append(Text())
+    operations = turn.operations
+    children: dict[int, list[int]] = defaultdict(list)
+    has_parent: set[int] = set()
+    for source, target in flow.parent_edges():
+        if FLOW_TERMINAL_INDEX in (source, target):
+            continue
+        children[source].append(target)
+        has_parent.add(target)
+    causal_in: dict[int, list[int]] = defaultdict(list)
+    terminal_fan_in = 0
+    for source, target in flow.causal_edges():
+        if target == FLOW_TERMINAL_INDEX:
+            terminal_fan_in += 1
+        elif source != FLOW_TERMINAL_INDEX:
+            causal_in[target].append(source)
+
+    def order_key(index: int) -> tuple[bool, int, int]:
+        operation = operations[index]
+        return (operation.start_ns is None, operation.start_ns or 0, index)
+
+    roots = sorted((index for index in range(len(operations)) if index not in has_parent), key=order_key)
+    for child_list in children.values():
+        child_list.sort(key=order_key)
+    seen: set[int] = set()
+    stack = [(index, 0) for index in reversed(roots)]
+    while stack:
+        index, depth = stack.pop()
+        if index in seen:
+            continue
+        seen.add(index)
+        unproven = depth == 0 and index != flow.root_index and not causal_in.get(index)
+        lines.append(
+            _dependency_node_line(
+                look,
+                operations,
+                index,
+                depth=depth,
+                causal_sources=causal_in.get(index, []),
+                unproven=unproven,
+            )
+        )
+        stack.extend((child, depth + 1) for child in reversed(children.get(index, [])))
+        # A parent cycle leaves its members without a reachable root; once
+        # the reachable forest drains, surface them flat rather than drop
+        # them (the cycle warning above explains the shape).
+        if not stack:
+            leftovers = sorted((index for index in range(len(operations)) if index not in seen), key=order_key)
+            stack = [(index, 0) for index in reversed(leftovers)]
+    if flow.has_terminal:
+        lines.append(
+            Text.assemble(
+                Text(" " * _OPERATION_CATEGORY_WIDTH),
+                Text(_OPERATION_CATEGORY_SEPARATOR),
+                Text("◆ ", style=section_style(look)),
+                Text(look.message(_GRAPH_RESPONSE.bind()), style=section_style(look)),
+                Text(f"  ⇠ {terminal_fan_in}", style="dim"),
+            )
+        )
+    return lines
+
+
+def _dependency_node_line(
+    look: DashboardLook,
+    operations: tuple[TimelineOperation, ...],
+    index: int,
+    *,
+    depth: int,
+    causal_sources: list[int],
+    unproven: bool,
+) -> Text:
+    operation = operations[index]
+    style = _operation_style(look, operation.family)
+    parts = [
+        fit_text_cells(Text(_family_category(look, operation.family), style=style), _OPERATION_CATEGORY_WIDTH),
+        Text(_OPERATION_CATEGORY_SEPARATOR),
+        Text("│ " * depth, style="dim"),
+    ]
+    if unproven:
+        parts.append(Text("┄ ", style="dim"))
+    parts.append(Text(_operation_identity(look, operation), style=style))
+    duration = operation.duration_ns
+    if duration is not None:
+        parts.append(Text(f"  {format_duration(duration)}", style="dim"))
+    parts.extend((Text(" "), precision_badge(look, operation.precision)))
+    if causal_sources:
+        labels = ", ".join(_operation_identity(look, operations[source]) for source in causal_sources[:2])
+        extra = len(causal_sources) - 2
+        suffix = f" +{extra}" if extra > 0 else ""
+        parts.append(Text(f"  ⇠ {labels}{suffix}", style="dim"))
+    return Text.assemble(*parts)
+
+
+def _operation_category(look: DashboardLook, operation: TimelineOperation) -> str:
+    return _family_category(look, operation.family)
+
+
+def _family_category(look: DashboardLook, family: str) -> str:
+    if family.startswith("workflow."):
+        from chrys.app.tui.widgets.workflow.text import TITLE
+
+        label = TITLE
+    elif family.startswith("model."):
+        label = _CATEGORY_MODEL
+    elif family == "tool.operation":
+        label = _CATEGORY_TOOL
+    elif family in {"wait", "continuation.poll", "turn.suspension"}:
+        label = _CATEGORY_WAIT
+    elif family == "hook.operation":
+        label = _CATEGORY_HOOK
+    elif family == "sub_agent":
+        label = _CATEGORY_AGENT
+    elif family == "preparation":
+        label = _CATEGORY_PREPARATION
+    elif family.startswith("compaction"):
+        label = _CATEGORY_COMPACTION
+    elif family == "approval":
+        label = _CATEGORY_APPROVAL
+    elif family == "retry":
+        label = _CATEGORY_RETRY
+    else:
+        label = _CATEGORY_OPERATION
+    return look.message(label.bind())
+
+
+def _operation_identity(look: DashboardLook, operation: TimelineOperation) -> str:
+    if operation.identity is not None:
+        return identity_with_hook_id(operation.identity, operation.hook_id)
+    if operation.family == "tool.operation":
+        return look.message(_CATEGORY_TOOL.bind())
+    if operation.family == "hook.operation":
+        return look.message(_CATEGORY_HOOK.bind())
+    if operation.family in {"wait", "continuation.poll", "turn.suspension"}:
+        return look.message(_CATEGORY_WAIT.bind())
+    if operation.family == "sub_agent":
+        return look.message(_CATEGORY_AGENT.bind())
+    return operation.family.removeprefix("model.").removeprefix("compaction.")
+
+
+def _metric_text(look: DashboardLook, metric: Metric) -> Text:
+    return Text.assemble(Text(metric_value(metric)), Text(" "), precision_badge(look, metric.precision))
+
+
+def _operation_style(look: DashboardLook, family: str) -> Style:
+    if family.startswith(("model.", "compaction", "workflow.")):
+        return look.semantic_style("primary", "blue", bold=True)
+    if family == "tool.operation" or family == "preparation":
+        return look.semantic_style("warning", "yellow", bold=True)
+    if family == "hook.operation":
+        return rich_style_from_textual_color("ansi_cyan", bold=True)
+    if family in {"wait", "approval", "retry", "continuation.poll", "turn.suspension"}:
+        return look.semantic_style("accent", "magenta", bold=True)
+    if family == "sub_agent":
+        return look.semantic_style("secondary", "cyan", bold=True)
+    return look.semantic_style("foreground", "white")
+
+
+def _operation_bar_style(look: DashboardLook, family: str) -> Style:
+    if family == "model.run":
+        return look.semantic_style("accent", "magenta", bold=True)
+    return _operation_style(look, family)
+
+
+def _zebra_style(look: DashboardLook) -> Style:
+    return _blended_style(look, 0.08, fill_background=True) or Style()
+
+
+def _blended_style(look: DashboardLook, factor: float, *, fill_background: bool) -> Style | None:
+    """Blend the theme background toward the foreground; None when not blendable (ANSI)."""
+    variables = look.theme_variables
+    try:
+        background = Color.parse(variables.get("background", ""))
+        foreground = Color.parse(variables.get("foreground", ""))
+    except ColorParseError:
+        return None
+    if background.ansi is not None or foreground.ansi is not None:
+        return None
+    blended = background.blend(foreground, factor)
+    if fill_background:
+        return Style(bgcolor=blended.rich_color)
+    return Style(color=blended.rich_color)
+
+
+def _operation_glyph(family: str) -> str:
+    if family.startswith("model."):
+        return "▮"
+    if family in {"wait", "approval", "retry", "continuation.poll", "turn.suspension"}:
+        return "▭"
+    if family == "hook.operation":
+        return "◆"
+    return "▨"

chrys/app/tui/widgets/welcome.py

@@ -0,0 +1,126 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Shared, centered welcome surface with a configurable logo and context."""
+
+from __future__ import annotations
+
+from textwrap import dedent
+from typing import TYPE_CHECKING
+
+from rich.cells import cell_len, set_cell_size
+from rich.segment import Segment
+from rich.style import Style
+from rich.text import Text
+from textual.widget import Widget
+
+if TYPE_CHECKING:
+    from rich.console import Console, ConsoleOptions, RenderResult
+    from textual.geometry import Size
+
+
+class _WelcomeRenderable:
+    """Fill the available area with a centered logo, title and working directory."""
+
+    def __init__(
+        self,
+        logo_lines: tuple[str, ...],
+        title: str,
+        cwd: str,
+        width: int,
+        height: int,
+        logo_style: Style,
+    ) -> None:
+        self.logo_lines = logo_lines
+        self.title = title
+        self.cwd = cwd
+        self.width = width
+        self.height = height
+        self.logo_style = logo_style
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        width, height = self.width, self.height
+        if width <= 0 or height <= 0:
+            return
+
+        logo_width = max((cell_len(line) for line in self.logo_lines), default=0)
+        logo_left = max(0, (width - logo_width) // 2)
+        rows = [(logo_left, line, self.logo_style) for line in self.logo_lines]
+        info = [(self.title, Style(bold=True)), (self.cwd, Style(dim=True))]
+        if any(value for value, _style in info):
+            rows.append((0, "", Style()))
+        for value, style in info:
+            if value:
+                line = Text(value)
+                line.truncate(width, overflow="ellipsis")
+                rows.append((max(0, (width - line.cell_len) // 2), line.plain, style))
+
+        top = max(0, (height - len(rows)) // 2)
+        for y in range(height):
+            row = y - top
+            if 0 <= row < len(rows):
+                left, value, style = rows[row]
+                yield Segment(" " * left)
+                yield Segment(set_cell_size(value, width - left), style)
+            else:
+                yield Segment(" " * width)
+            yield Segment.line()
+
+
+class WelcomeWidget(Widget):
+    """Reusable empty state; callers own mode selection and localized display text."""
+
+    DEFAULT_CSS = """
+    WelcomeWidget {
+        width: 100%;
+        height: 100%;
+        color: $foreground;
+    }
+    """
+
+    def __init__(
+        self,
+        logo: str,
+        *,
+        title: str = "",
+        cwd: str = "",
+        compact_logo: str = "",
+        id: str | None = None,
+    ) -> None:
+        super().__init__(id=id)
+        self._logo_lines = tuple(
+            dedent("\n".join(line.rstrip() for line in logo.splitlines())).strip("\n").splitlines()
+        )
+        self._logo_width = max((cell_len(line) for line in self._logo_lines), default=0)
+        self._title = title
+        self._cwd = cwd
+        self._compact_logo = compact_logo
+
+    def update_info(self, *, title: str | None = None, cwd: str | None = None, compact_logo: str | None = None) -> None:
+        """Update context without scheduling a repaint for unchanged values."""
+        values = (
+            self._title if title is None else title,
+            self._cwd if cwd is None else cwd,
+            self._compact_logo if compact_logo is None else compact_logo,
+        )
+        if values != (self._title, self._cwd, self._compact_logo):
+            self._title, self._cwd, self._compact_logo = values
+            height = self.styles.height
+            self.refresh(layout=height is not None and height.is_auto)
+
+    def _visible_logo(self, width: int) -> tuple[str, ...]:
+        # A compact wordmark keeps wide ASCII art readable in narrow panels.
+        return (self._compact_logo,) if self._compact_logo and width < self._logo_width else self._logo_lines
+
+    def get_content_height(self, container: Size, viewport: Size, width: int) -> int:
+        info_height = bool(self._title) + bool(self._cwd)
+        return len(self._visible_logo(width)) + (1 + info_height if info_height else 0)
+
+    def render(self) -> _WelcomeRenderable:
+        return _WelcomeRenderable(
+            self._visible_logo(self.size.width),
+            self._title,
+            self._cwd,
+            self.size.width,
+            self.size.height,
+            Style(color=self.rich_style.color, bold=True),
+        )

chrys/app/tui/widgets/workflow/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Workflow selection, graph and run presentation."""
+
+from __future__ import annotations

chrys/app/tui/widgets/workflow/edges.py

@@ -0,0 +1,89 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Cell-indexed connection ink, independent of graph layout and animation frames."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from itertools import pairwise
+
+from rich.cells import cell_len
+from rich.style import Style
+
+from chrys.app.tui.widgets.markdown.diagram.canvas import CellStyleSpan
+from chrys.app.tui.widgets.markdown.diagram.model import CompiledDiagram, PlacedNode
+from chrys.app.tui.widgets.workflow import text
+
+
+@dataclass(frozen=True, slots=True)
+class EdgeCell:
+    """One visible route cell and its distance from the source node."""
+
+    x: int
+    edge: int
+    distance: int
+
+
+def connection_state(source: str, target: str) -> str:
+    """Show endpoint readiness, not a claim that a conditional edge was taken.
+
+    Only connections feeding an executing node animate. A running source alone
+    must never light up its as-yet undecided outgoing branches.
+    """
+    if "skipped" in (source, target):
+        return "skipped"
+    if source not in {"completed", "running"}:
+        return "pending"
+    return target if target in text.STATES else "pending"
+
+
+def edge_cells(diagram: CompiledDiagram, nodes: Mapping[str, PlacedNode]) -> dict[int, tuple[EdgeCell, ...]]:
+    """Index once per layout, excluding cards and all labels (including wide text)."""
+    occupied: dict[int, list[tuple[int, int]]] = {}
+    for box in nodes.values():
+        for y in range(box.y, box.y + box.height):
+            occupied.setdefault(y, []).append((box.x, box.x + box.width))
+    for route in diagram.routed_edges:
+        for point, label in (
+            (route.label_at, route.edge.label),
+            (route.source_label_at, route.edge.source_label),
+            (route.target_label_at, route.edge.target_label),
+        ):
+            if point is not None:
+                occupied.setdefault(point.y, []).append((point.x, point.x + cell_len(label)))
+    rows: dict[int, list[EdgeCell]] = {}
+    for index, route in enumerate(diagram.routed_edges):
+        distance = 0
+        points = route.points
+        for start, end in pairwise(points):
+            dx, dy = (end.x > start.x) - (end.x < start.x), (end.y > start.y) - (end.y < start.y)
+            length = abs(end.x - start.x) + abs(end.y - start.y)
+            for step in range(length):
+                x, y = start.x + dx * step, start.y + dy * step
+                if not any(left <= x < right for left, right in occupied.get(y, ())):
+                    rows.setdefault(y, []).append(EdgeCell(x, index, distance + step))
+            distance += length
+        if points:
+            x, y = points[-1].x, points[-1].y
+            if not any(left <= x < right for left, right in occupied.get(y, ())):
+                rows.setdefault(y, []).append(EdgeCell(x, index, distance))
+    return {y: tuple(cells) for y, cells in rows.items()}
+
+
+def pulse_strength(distance: int, frame: int) -> int:
+    """A compact head and fading tail travel toward the target without blinking."""
+    behind = (frame - distance) % 16
+    return 3 if behind < 2 else 2 if behind < 4 else 1 if behind < 7 else 0
+
+
+def ink_spans(cells: Mapping[int, Style]) -> tuple[CellStyleSpan, ...]:
+    """Merge adjacent ink so long connections stay cheap to crop and repaint."""
+    spans: list[CellStyleSpan] = []
+    for x, style in sorted(cells.items()):
+        if spans and spans[-1].end == x and spans[-1].style == style:
+            previous = spans[-1]
+            spans[-1] = CellStyleSpan(previous.start, x + 1, style)
+        else:
+            spans.append(CellStyleSpan(x, x + 1, style))
+    return tuple(spans)