pythinker-code 0.8.0__py3-none-any.whl

pythinker_code/ui/shell/components/__init__.py

@@ -0,0 +1,110 @@
+"""Pythinker TUI component foundation.
+
+This package provides reusable rendering primitives modeled after the
+internal component system. Most components are pure data-to-Rich-renderable
+adapters; prompt_toolkit-backed interactive components live here too when
+shared across selectors.
+"""
+
+from __future__ import annotations
+
+from pythinker_code.ui.shell.components.base import TuiComponent
+from pythinker_code.ui.shell.components.bash_execution import (
+    BashExecutionState,
+    render_bash_execution,
+)
+from pythinker_code.ui.shell.components.bordered_loader import (
+    BorderedLoaderState,
+    render_bordered_loader,
+)
+from pythinker_code.ui.shell.components.diff import (
+    EditDiffResult,
+    compute_edit_diff_string,
+    render_diff,
+)
+from pythinker_code.ui.shell.components.footer import (
+    FooterState,
+    FooterUsage,
+    format_tokens,
+    render_footer,
+)
+from pythinker_code.ui.shell.components.key_hints import key_hint, raw_key_hint
+from pythinker_code.ui.shell.components.messages import (
+    AssistantContent,
+    CustomMessageInput,
+    render_assistant_message,
+    render_custom_message,
+    render_user_message,
+)
+from pythinker_code.ui.shell.components.render_utils import (
+    VisualTruncateResult,
+    cell_width,
+    dim,
+    render_message_response,
+    render_plain,
+    sanitize_ansi,
+    truncate_middle_to_visual_lines,
+    truncate_to_visual_lines,
+    truncate_to_width,
+)
+from pythinker_code.ui.shell.components.settings_list import (
+    SettingItem,
+    SettingsListConfig,
+    SettingsListResult,
+    run_settings_list,
+)
+from pythinker_code.ui.shell.components.special_messages import (
+    BranchSummaryInput,
+    CompactionSummaryInput,
+    SkillInvocationInput,
+    render_branch_summary,
+    render_compaction_summary,
+    render_skill_invocation,
+)
+from pythinker_code.ui.shell.components.tool_execution import (
+    ToolExecutionComponent,
+    ToolExecutionStatus,
+)
+
+__all__ = [
+    "AssistantContent",
+    "BashExecutionState",
+    "BorderedLoaderState",
+    "BranchSummaryInput",
+    "CompactionSummaryInput",
+    "CustomMessageInput",
+    "EditDiffResult",
+    "FooterState",
+    "FooterUsage",
+    "SettingItem",
+    "SettingsListConfig",
+    "SettingsListResult",
+    "SkillInvocationInput",
+    "ToolExecutionComponent",
+    "ToolExecutionStatus",
+    "TuiComponent",
+    "VisualTruncateResult",
+    "cell_width",
+    "compute_edit_diff_string",
+    "dim",
+    "format_tokens",
+    "key_hint",
+    "raw_key_hint",
+    "render_assistant_message",
+    "render_bash_execution",
+    "render_bordered_loader",
+    "render_branch_summary",
+    "render_compaction_summary",
+    "render_custom_message",
+    "render_diff",
+    "render_footer",
+    "render_message_response",
+    "render_plain",
+    "run_settings_list",
+    "render_skill_invocation",
+    "render_user_message",
+    "sanitize_ansi",
+    "truncate_middle_to_visual_lines",
+    "truncate_to_visual_lines",
+    "truncate_to_width",
+]

pythinker_code/ui/shell/components/base.py

@@ -0,0 +1,25 @@
+"""Component protocol shared by Pythinker TUI components."""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+from rich.console import RenderableType
+
+
+@runtime_checkable
+class TuiComponent(Protocol):
+    """Renders to one or more Rich renderables, sized to a target cell width.
+
+    Implementations should be pure: identical inputs produce identical output.
+    State changes are signalled via :meth:`invalidate` so a host renderer can
+    drop any cached output.
+    """
+
+    def render(self, width: int) -> RenderableType | list[RenderableType]:
+        """Return Rich renderable(s) sized to *width* terminal cells."""
+        ...
+
+    def invalidate(self) -> None:
+        """Drop cached render output. Called when component state changes."""
+        ...

pythinker_code/ui/shell/components/bash_execution.py

@@ -0,0 +1,249 @@
+"""Pythinker bash execution component.
+
+
+
+Render bash as a compact Codex-style execution cell: a lifecycle bullet,
+a ``$ <command>`` header, indented output, and small status/footer hints.
+We model the same shape as a stateless Rich renderable factory so callers
+(the bash tool renderer or future ``Shell`` history) can drive it.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Literal
+
+from rich.console import Group, RenderableType
+from rich.style import Style as RichStyle
+from rich.text import Text
+
+from pythinker_code.ui.shell.components.render_utils import (
+    sanitize_ansi,
+    truncate_middle_to_visual_lines,
+)
+from pythinker_code.ui.theme import tui_rich_style
+
+__all__ = [
+    "BashExecutionState",
+    "format_bash_command_for_header",
+    "render_bash_execution",
+    "render_bash_result_output",
+]
+
+PREVIEW_LINES = 5
+MAX_COMMAND_DISPLAY_LINES = 2
+MAX_COMMAND_DISPLAY_CHARS = 160
+
+BashStatus = Literal["pending", "running", "complete", "error", "cancelled"]
+
+
+@dataclass(frozen=True, slots=True)
+class BashExecutionState:
+    """Inputs for :func:`render_bash_execution`.
+
+    Attributes:
+        command: The shell command being executed.
+        output: Combined stdout/stderr captured so far. Streaming-friendly —
+            callers may pass partial output on every redraw.
+        status: Lifecycle state. ``"pending"`` and ``"running"`` show the
+            spinner placeholder line; ``"complete"`` / ``"error"`` /
+            ``"cancelled"`` add a footer note.
+        exit_code: Exit code for the finished process (only used in the
+            ``"error"`` footer line).
+        expanded: When ``True`` the full output is shown; otherwise the
+            tail is truncated to ``PREVIEW_LINES`` lines.
+        truncated: ``True`` when ``output`` was already byte-truncated
+            upstream (for the LLM context cap). Drives the trailing hint.
+        full_output_path: Optional spill-file path for very long output.
+        exclude_from_context: ``!!`` prefix mode — render in dim instead of
+            the bash-mode accent.
+    """
+
+    command: str
+    output: str = ""
+    status: BashStatus = "running"
+    exit_code: int | None = None
+    expanded: bool = False
+    truncated: bool = False
+    full_output_path: str | None = None
+    exclude_from_context: bool = False
+    header_suffix: str = ""
+    """Muted metadata appended after the command (e.g. ``" (timeout 600s)"``)."""
+
+
+def _accent_style(state: BashExecutionState) -> RichStyle:
+    return tui_rich_style("muted" if state.exclude_from_context else "bash_mode")
+
+
+def _output_lines(output: str) -> list[str]:
+    cleaned = sanitize_ansi(output).replace("\r\n", "\n").replace("\r", "\n")
+    if cleaned == "":
+        return []
+    return cleaned.split("\n")
+
+
+def _pulsing_marker() -> Text:
+    glyph = "●" if int(time.monotonic() / 0.8) % 2 == 0 else " "
+    return Text(f"{glyph} ", style=tui_rich_style("muted"))
+
+
+def _extract_comment_label(command: str) -> str | None:
+    for line in command.splitlines():
+        stripped = line.strip()
+        if not stripped:
+            continue
+        if stripped.startswith("#!"):
+            continue
+        if stripped.startswith("#"):
+            return stripped.lstrip("#").strip() or None
+        return None
+    return None
+
+
+def format_bash_command_for_header(command: str, *, expanded: bool) -> str:
+    if expanded:
+        return command
+
+    label = _extract_comment_label(command)
+    if label:
+        command = label
+
+    lines = command.splitlines()
+    needs_line_truncation = len(lines) > MAX_COMMAND_DISPLAY_LINES
+    needs_char_truncation = len(command) > MAX_COMMAND_DISPLAY_CHARS
+    if not needs_line_truncation and not needs_char_truncation:
+        return command
+
+    truncated = "\n".join(lines[:MAX_COMMAND_DISPLAY_LINES]) if needs_line_truncation else command
+    if len(truncated) > MAX_COMMAND_DISPLAY_CHARS:
+        truncated = truncated[:MAX_COMMAND_DISPLAY_CHARS]
+    return truncated.rstrip() + "…"
+
+
+def _status_header(state: BashExecutionState) -> Text:
+    accent = _accent_style(state)
+    if state.status in ("pending", "running"):
+        header = _pulsing_marker()
+        header.append("Running", style=tui_rich_style("muted") + RichStyle(bold=True))
+    elif state.status == "error":
+        header = Text("✘ ", style=tui_rich_style("error"))
+        header.append("Ran", style=tui_rich_style("error") + RichStyle(bold=True))
+    elif state.status == "cancelled":
+        header = Text("● ", style=tui_rich_style("warning"))
+        header.append("Cancelled", style=tui_rich_style("warning") + RichStyle(bold=True))
+    else:
+        header = Text("✔ ", style=tui_rich_style("success"))
+        header.append("Ran", style=tui_rich_style("success") + RichStyle(bold=True))
+
+    header.append(" ")
+    header.append("$ ", style=accent + RichStyle(bold=True))
+    header.append(
+        format_bash_command_for_header(state.command, expanded=state.expanded),
+        style=accent + RichStyle(bold=True),
+    )
+    if state.header_suffix:
+        header.append(state.header_suffix, style=tui_rich_style("muted"))
+    return header
+
+
+def _display_output_lines(state: BashExecutionState, *, width: int) -> tuple[list[str], int]:
+    lines = _output_lines(state.output)
+    if state.expanded:
+        return lines, 0
+    visual_width = max(1, width - 4)
+    result = truncate_middle_to_visual_lines(
+        "\n".join(lines),
+        max_visual_lines=PREVIEW_LINES,
+        width=visual_width,
+        hint="Ctrl+E expand",
+    )
+    return result.visual_lines, result.skipped_count
+
+
+def _output_block(display: list[str]) -> Text | None:
+    if not display:
+        return None
+    body = Text(style=tui_rich_style("muted"))
+    for index, line in enumerate(display):
+        if index:
+            body.append("\n")
+        body.append("  ⎿ " if index == 0 else "    ")
+        body.append(line)
+    return body
+
+
+def _result_output_block(display: list[str]) -> Text | None:
+    if not display:
+        return None
+    body = Text(style=tui_rich_style("muted"))
+    for index, line in enumerate(display):
+        if index:
+            body.append("\n")
+        body.append(line)
+    return body
+
+
+def _bash_footer_lines(
+    state: BashExecutionState, *, hidden: int, total_output_lines: int
+) -> list[Text]:
+    footer_lines: list[Text] = []
+    if hidden > 0 and state.expanded:
+        footer_lines.append(Text("ctrl+e to collapse", style=tui_rich_style("muted")))
+    if state.status == "cancelled":
+        footer_lines.append(Text("cancelled", style=tui_rich_style("warning")))
+    elif state.status == "error":
+        code = state.exit_code if state.exit_code is not None else "?"
+        footer_lines.append(Text(f"exit {code}", style=tui_rich_style("error")))
+    elif state.status in ("pending", "running"):
+        footer_lines.append(
+            Text("esc to cancel · ctrl+b background", style=tui_rich_style("muted"))
+        )
+    elif total_output_lines > PREVIEW_LINES and not state.expanded:
+        footer_lines.append(
+            Text(f"{total_output_lines} lines · ctrl+e expand", style=tui_rich_style("muted"))
+        )
+
+    if state.truncated and state.full_output_path:
+        footer_lines.append(
+            Text(
+                f"output truncated · full output: {state.full_output_path}",
+                style=tui_rich_style("warning"),
+            )
+        )
+    return footer_lines
+
+
+def render_bash_result_output(state: BashExecutionState, *, width: int = 100) -> RenderableType:
+    """Render only bash output/status for placement under a response gutter.
+
+    The tool header is rendered by the caller, so this avoids the duplicate
+    ``Ran $ ...`` line and avoids embedding another ``⎿`` gutter inside the
+    shared ``MessageResponse`` gutter.
+    """
+    display, hidden = _display_output_lines(state, width=width)
+    total_output_lines = len(_output_lines(state.output))
+    children: list[RenderableType] = []
+    output = _result_output_block(display)
+    if output is not None:
+        children.append(output)
+    elif state.status not in ("pending", "running"):
+        children.append(Text("(No output)", style=tui_rich_style("muted")))
+    children.extend(_bash_footer_lines(state, hidden=hidden, total_output_lines=total_output_lines))
+    return Group(*children) if len(children) > 1 else children[0]
+
+
+def render_bash_execution(state: BashExecutionState, *, width: int = 100) -> RenderableType:
+    """Build the standalone bash execution renderable for *state*."""
+    display, hidden = _display_output_lines(state, width=width)
+    total_output_lines = len(_output_lines(state.output))
+
+    children: list[RenderableType] = [_status_header(state)]
+    output = _output_block(display)
+    if output is not None:
+        children.append(output)
+    for line in _bash_footer_lines(state, hidden=hidden, total_output_lines=total_output_lines):
+        indented = Text("  ", style=line.style)
+        indented.append_text(line)
+        children.append(indented)
+    return Group(*children)

pythinker_code/ui/shell/components/bordered_loader.py

@@ -0,0 +1,62 @@
+"""Bordered spinner card with optional cancel hint.
+
+A Rich-friendly stand-in for the bordered loader pattern used elsewhere in
+the TUI — top/bottom rules in the active accent color, a centered spinner +
+message, and an optional ``esc to cancel`` line. Stateless: callers pass a
+:class:`BorderedLoaderState` and re-call :func:`render_bordered_loader`
+each tick.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+
+from rich.console import Group, RenderableType
+from rich.rule import Rule
+from rich.text import Text
+
+from pythinker_code.ui.shell.keymap import key_text
+from pythinker_code.ui.theme import tui_rich_style
+
+__all__ = [
+    "BorderedLoaderState",
+    "render_bordered_loader",
+]
+
+
+@dataclass(frozen=True, slots=True)
+class BorderedLoaderState:
+    """Inputs for :func:`render_bordered_loader`.
+
+    Attributes:
+        message: Status text shown next to the spinner.
+        cancellable: When ``True``, append a ``<esc> cancel`` hint line.
+        spinner: Deprecated; loading now renders as the shared solid circle.
+        accent_token: TUI token name for the border + spinner color.
+    """
+
+    message: str
+    cancellable: bool = True
+    spinner: str = "dots"
+    accent_token: str = "border_accent"
+
+
+def render_bordered_loader(state: BorderedLoaderState) -> RenderableType:
+    """Build the bordered loader renderable for *state*."""
+    accent = tui_rich_style(state.accent_token)
+    muted = tui_rich_style("muted")
+
+    glyph = "●" if int(time.monotonic() / 0.8) % 2 == 0 else " "
+    loading = Text(f"{glyph} ", style=muted)
+    loading.append(state.message, style=muted)
+
+    children: list[RenderableType] = [Rule(style=accent), loading]
+    if state.cancellable:
+        cancel_key = key_text("tui.select.cancel") or "esc"
+        hint = Text()
+        hint.append(cancel_key, style=tui_rich_style("dim"))
+        hint.append(" cancel", style=muted)
+        children.append(hint)
+    children.append(Rule(style=accent))
+    return Group(*children)