Merge feat/tui-streaming-phase0 into main

Author: elkaix

CHANGELOG.md

@@ -15,8 +15,24 @@ GitHub Releases page; `0.8.0` is the new starting line.
 
 ## Unreleased
 
+- **Tool header highlights.** Read/Write/Edit/Grep and similar tool-call subjects
+  now use the brand periwinkle `accent` token instead of cyan `info`; line ranges
+  stay on the yellow `warning` token.
+- **pythinker-x theme port.** Diff palette, 32 bundled syntax theme names, Catppuccin
+  Frappe/Macchiato styles, and `/theme code` syntax picker aligned with the Pythinker-X TUI.
+- **TUI inline code color.** Inline `` `code` `` highlights and the `pythinker-ansi`
+  syntax theme now use brand periwinkle/accent and blue ANSI roles instead of cyan.
+- **TUI transcript spacing.** User prompts leave one blank row before the agent stream
+  starts; finished tool cards and flushed agent paragraphs leave a trailing blank row
+  before the next block (Bash/Read output → next ⏺ paragraph, etc.).
+- **Welcome banner colors.** Branch uses light neutral grey; model name uses the muted
+  yellow warning token.
 - **TUI theme package.** Centralize dark/light palettes, prompt classes, and Rich/PTK
   adapters in `ui/theme/` with `/theme current|doctor|tokens` inspection commands.
+- **TUI diff markers.** Inline diff rows now leave a space after `+`/`-` markers so
+  `@`-prefixed lines (e.g. CSS `@keyframes`) do not run together with the sign.
+- **Composing block spacing.** Staged agent paragraphs keep one blank row before the
+  Composing activity line while the stream is still live.
 - **Slash input UX.** Prefix-highlight skills and plugins while typing; ghost-complete
   and highlight fixed subcommands such as `/theme current`.
 - **TUI streaming smoothness (Phase 0).** Coalesce Rich Live repaints to a 25 Hz frame budget,
@@ -27,6 +43,11 @@ GitHub Releases page; `0.8.0` is the new starting line.
   (go-to-definition, find-references, hover, symbols, call hierarchy) with session-scoped
   server lifecycle, passive diagnostics injected after file edits, and plugin-based server
   discovery/recommendation — no bundled language-server binaries.
+- **Token activity card.** `/usage daily|weekly|cumulative` (and the bare `/usage` default
+  when no provider adapter is configured) now render a 52-week × 7-day heatmap of
+  total tokens consumed each day, with a `Lifetime · Peak · Streak · Longest task` summary
+  line and a footer that lets the user switch between daily/weekly/cumulative views. Data is
+  read from the local session wire files; the per-provider adapter behavior is unchanged.
 
 ## 0.47.0 (2026-06-16)
 

docs/public/install.sh

@@ -2402,11 +2402,9 @@ def _value_style_for_label(label: str, level: WelcomeInfoItem.Level) -> str:
     if label == "Session":
         return tokens.dim or "grey39"
     if label == "Model":
-        return f"bold {tokens.text}" if tokens.text else "bold bright_white"
+        return tokens.warning or "#EAB85F"
     if label == "Branch":
-        from pythinker_code.ui.theme import get_statusline_colors
-
-        return get_statusline_colors().branch.removeprefix("fg:")
+        return tokens.thinking_text or "grey70"
     if label == "Auto-save":
         return tokens.muted or "grey50"
     return level.value

scripts/install-native.sh

@@ -313,28 +313,28 @@ def _newline() -> None:
                     _replace_tabs(acontent),
                 )
                 _newline()
-                row = Text(f"{rln} -", style=removed_sign)
+                row = Text(f"{rln} - ", style=removed_sign)
                 # Underlay the row tint so word-level highlight spans stay on top.
                 rem_inner.stylize_before(removed_body)
                 row.append_text(rem_inner)
                 out.append_text(row)
                 _newline()
-                row = Text(f"{aln} +", style=added_sign)
+                row = Text(f"{aln} + ", style=added_sign)
                 add_inner.stylize_before(added_body)
                 row.append_text(add_inner)
                 out.append_text(row)
             else:
                 for ln, content in removed_block:
                     _newline()
-                    out.append(f"{ln} -", style=removed_sign)
+                    out.append(f"{ln} - ", style=removed_sign)
                     out.append(_replace_tabs(content), style=removed_body)
                 for ln, content in added_block:
                     _newline()
-                    out.append(f"{ln} +", style=added_sign)
+                    out.append(f"{ln} + ", style=added_sign)
                     out.append(_replace_tabs(content), style=added_body)
         elif prefix == "+":
             _newline()
-            out.append(f"{line_num} +", style=added_sign)
+            out.append(f"{line_num} + ", style=added_sign)
             out.append(_replace_tabs(content), style=added_body)
             i += 1
         else:

src/pythinker_code/ui/shell/__init__.py

@@ -792,7 +792,8 @@ class PythinkerMarkdown(Markdown):
         "table_open": _ReportTableElement,
     }
 
-    def __init__(self, markup: str, *args: Any, **kwargs: Any) -> None:
+    def __init__(self, markup: str, *args: Any, report: bool = False, **kwargs: Any) -> None:
+        self._report_mode = report
         safe_markup = sanitize_ansi(markup)
         unwrapped_markup = _unwrap_fenced_markdown_tables(safe_markup)
         repaired_markup = _repair_crammed_markdown_tables(unwrapped_markup)
@@ -801,7 +802,13 @@ def __init__(self, markup: str, *args: Any, **kwargs: Any) -> None:
         super().__init__(_simplify_markdown_report_icons(loosened_markup), *args, **kwargs)
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
-        overrides = _markdown_style_overrides()
+        from pythinker_code.ui.theme.adapters.markdown import report_markdown_style_overrides
+
+        overrides = (
+            report_markdown_style_overrides()
+            if self._report_mode
+            else _markdown_style_overrides()
+        )
         with console.use_theme(Theme(overrides, inherit=True)):
             yield from super().__rich_console__(console, options)
 
@@ -814,6 +821,13 @@ def pythinker_markdown(text: str, *, code_theme: str | None = None) -> Pythinker
     return PythinkerMarkdown(text, code_theme=code_theme)
 
 
+def pythinker_report_markdown(
+    text: str, *, code_theme: str | None = None, style: str | RichStyle = "none"
+) -> PythinkerMarkdown:
+    """Report-body markdown: only H1 headings render bold; everything else is regular weight."""
+    return PythinkerMarkdown(text, code_theme=code_theme, style=style, report=True)
+
+
 # ---------------------------------------------------------------------------
 # Streaming boundary helper
 # ---------------------------------------------------------------------------

src/pythinker_code/ui/shell/components/diff.py

@@ -34,9 +34,10 @@
 from rich.table import Table
 from rich.text import Text
 
-from pythinker_code.ui.shell.components.markdown import PythinkerMarkdown, pythinker_markdown
+from pythinker_code.ui.shell.components.markdown import pythinker_markdown, pythinker_report_markdown
+from pythinker_code.ui.shell.glyphs import REPORT_FILE_MARKER
 from pythinker_code.ui.shell.spacing import REPORT_PANEL_PADDING
-from pythinker_code.ui.theme import ThemeName, tui_rich_style
+from pythinker_code.ui.theme import ThemeName, get_tui_tokens, tui_rich_style
 
 _log = logging.getLogger(__name__)
 
@@ -56,14 +57,14 @@
 _SEVERITY_ORDER: tuple[Severity, ...] = get_args(Severity)
 _SEVERITY_SET = frozenset(_SEVERITY_ORDER)
 
-# severity -> (token name, bold). Muted theme tokens only; critical is the one
-# emphasis (bold) so the eye lands on it without a brighter colour.
+# severity -> (token name, bold). Report panels keep body text regular weight;
+# only the panel title (H1 equivalent) uses bold.
 _SEVERITY_TOKEN: dict[Severity, tuple[str, bool]] = {
-    "critical": ("error", True),
+    "critical": ("error", False),
     "high": ("error", False),
     "medium": ("warning", False),
     "low": ("accent", False),
-    "info": ("muted", False),
+    "info": ("activity_spinner", False),
 }
 
 _DOT = "●"
@@ -251,19 +252,19 @@ def _render_report_prose(text: str, *, theme: ThemeName | None = None) -> Render
 
     rows: list[RenderableType] = []
     if report.preamble.strip():
-        rows.append(pythinker_markdown(report.preamble))
+        rows.append(pythinker_report_markdown(report.preamble))
 
     body_style = tui_rich_style("text", theme=theme)
     for section in report.sections:
         if rows:
             rows.append(Text(""))
-        # Use a lower-level Markdown heading so inline code / links inside labels
-        # keep the standard muted-blue highlight without promoting every report
-        # subsection to the muted-yellow H1 treatment.
-        rows.append(PythinkerMarkdown(f"### {section.title}"))
+        rows.append(pythinker_report_markdown(f"# {section.title}"))
         if section.body.strip():
             rows.append(
-                Padding(PythinkerMarkdown(section.body.strip(), style=body_style), (0, 0, 0, 2))
+                Padding(
+                    pythinker_report_markdown(section.body.strip(), style=body_style),
+                    (0, 0, 0, 2),
+                )
             )
 
     return Group(*rows)
@@ -282,24 +283,50 @@ def _severity_style(severity: Severity, theme: ThemeName | None) -> RichStyle:
     return style + RichStyle(bold=True) if bold else style
 
 
+def _strong_style(theme: ThemeName | None) -> RichStyle:
+    return tui_rich_style("tool_title", theme=theme) + RichStyle(bold=True)
+
+
+def _primary_style(theme: ThemeName | None) -> RichStyle:
+    return tui_rich_style("text", theme=theme)
+
+
+def _secondary_style(theme: ThemeName | None) -> RichStyle:
+    return tui_rich_style("secondary", theme=theme)
+
+
+def _muted_style(theme: ThemeName | None) -> RichStyle:
+    return tui_rich_style("muted", theme=theme)
+
+
 def _summary_line(counts: dict[Severity, int], theme: ThemeName | None) -> Text:
     line = Text()
+    pill_bg = get_tui_tokens(theme).tool_pending_bg
+    bg = RichStyle(bgcolor=pill_bg)
     first = True
     for severity in _SEVERITY_ORDER:
         count = counts[severity]
         if not count:
             continue
         if not first:
-            line.append("   ")
+            line.append("  ")
         first = False
-        line.append(f"{_DOT} ", style=_severity_style(severity, theme))
-        line.append(f"{count} {severity}", style=tui_rich_style("text", theme=theme))
+        line.append(f" {_DOT} ", style=_severity_style(severity, theme) + bg)
+        line.append(f"{count} {severity} ", style=_primary_style(theme) + bg)
     if not counts["critical"] and not counts["high"]:
-        prefix = "   " if not first else ""
-        line.append(f"{prefix}no critical or high", style=tui_rich_style("muted", theme=theme))
+        prefix = "  " if not first else ""
+        line.append(f"{prefix}no critical or high", style=_secondary_style(theme))
     return line
 
 
+def _render_section_header(severity: Severity, theme: ThemeName | None) -> Group:
+    border = tui_rich_style("border", theme=theme)
+    return Group(
+        Text(severity.capitalize(), style=tui_rich_style("tool_title", theme=theme)),
+        Rule(style=border, characters="─"),
+    )
+
+
 def _render_finding(finding: ReportFinding, theme: ThemeName | None) -> RenderableType:
     rows: list[RenderableType] = []
 
@@ -313,22 +340,29 @@ def _render_finding(finding: ReportFinding, theme: ThemeName | None) -> Renderab
     title.add_column(overflow="fold")
     title.add_row(
         Text(_DOT, style=_severity_style(finding.severity, theme)),
-        Text(finding.title, style=tui_rich_style("border", theme=theme) + RichStyle(bold=True)),
+        Text(finding.title, style=_primary_style(theme)),
     )
     rows.append(title)
 
     if finding.location:
-        # Keep wrapped file paths in the same hanging-indent column. A raw
-        # leading-space Text only indents the first physical line after Rich
-        # wraps, which makes long locations drift left inside wide reports.
-        rows.append(
-            Padding(Text(finding.location, style=tui_rich_style("dim", theme=theme)), (0, 0, 0, 2))
+        rows.append(Text(""))
+        muted = _muted_style(theme)
+        location = Table.grid(padding=0)
+        location.add_column(width=2, no_wrap=True)
+        location.add_column(overflow="fold")
+        location.add_row(
+            Text(REPORT_FILE_MARKER, style=muted),
+            Text(finding.location, style=muted),
         )
+        rows.append(location)
 
     if finding.body.strip():
-        body_style = tui_rich_style("text", theme=theme)
+        body_style = _primary_style(theme)
         rows.append(
-            Padding(PythinkerMarkdown(finding.body.strip(), style=body_style), (0, 0, 0, 2))
+            Padding(
+                pythinker_report_markdown(finding.body.strip(), style=body_style),
+                (0, 0, 0, 2),
+            )
         )
 
     return Group(*rows)
@@ -337,20 +371,20 @@ def _render_finding(finding: ReportFinding, theme: ThemeName | None) -> Renderab
 def render_report(report: Report, *, theme: ThemeName | None = None) -> RenderableType:
     """Render *report* as a padded, syntax-friendly Rich report panel."""
     counts = _counts(report.findings)
-    border = tui_rich_style("border_muted", theme=theme)
+    border = tui_rich_style("border", theme=theme)
     blank = Text("")
 
     rows: list[RenderableType] = []
     if report.scope:
-        rows += [Text(report.scope, style=tui_rich_style("dim", theme=theme)), blank]
+        rows += [Text(report.scope, style=_secondary_style(theme)), blank]
     rows.append(_summary_line(counts, theme))
 
     for severity in _SEVERITY_ORDER:
         group = [f for f in report.findings if f.severity == severity]
         if not group:
             continue
         rows.append(blank)
-        rows.append(Rule(f" {severity.capitalize()} ", align="left", style=border, characters="─"))
+        rows.append(_render_section_header(severity, theme))
         for finding in group:
             rows.append(blank)
             rows.append(_render_finding(finding, theme))
@@ -359,10 +393,10 @@ def render_report(report: Report, *, theme: ThemeName | None = None) -> Renderab
         rows += [
             blank,
             Rule(style=border, characters="─"),
-            Text(report.note, style=tui_rich_style("muted", theme=theme)),
+            Text(report.note, style=_secondary_style(theme)),
         ]
 
-    title = Text(report.title, style=tui_rich_style("warning", theme=theme) + RichStyle(bold=True))
+    title = Text(report.title, style=_strong_style(theme))
     return Panel(
         Group(*rows),
         title=title,

src/pythinker_code/ui/shell/components/markdown.py

@@ -34,7 +34,9 @@ def __rich_measure__(self, console: Console, options: ConsoleOptions) -> Measure
         return Measurement.get(console, options, self._block)
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
-        yield from console.render(Group(BLANK_ROW, self._block), options)
+        # Leading blank separates from prior scrollback; trailing blank gives one
+        # row of breathing room before the agent stream starts in the Live area.
+        yield from console.render(Group(BLANK_ROW, self._block, BLANK_ROW), options)
 
 
 def render_user_echo(message: Message) -> RenderableType:

src/pythinker_code/ui/shell/components/report.py

@@ -64,6 +64,8 @@
 #: inline view, interactive dialog body, pager, and ``prompt_other_input``.
 #: ASCII mode falls back to plain ``?`` for legacy terminals.
 QUESTION_MARKER: Final = "?" if _ASCII_GLYPHS else "❓"
+#: Report finding location rows (file path + line refs).
+REPORT_FILE_MARKER: Final = "+" if _ASCII_GLYPHS else "⌁"
 
 __all__ = [
     "SPINNER_FRAMES",
@@ -82,4 +84,5 @@
     "TRANSCRIPT_TOOL_GUTTER",
     "LIST_BULLET",
     "QUESTION_MARKER",
+    "REPORT_FILE_MARKER",
 ]

src/pythinker_code/ui/shell/echo.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from pythinker_code.ui.shell.selector import SelectorConfig, SelectorItem, run_selector
+
+
+def _build_code_theme_config(
+    current_theme: str,
+    available_themes: list[str],
+    on_preview: Callable[[str], None] | None = None,
+    *,
+    theme_matches_current: Callable[[str, str], bool] | None = None,
+) -> SelectorConfig[str]:
+    def _default_match(theme: str, configured: str) -> bool:
+        return theme == configured
+
+    matches = theme_matches_current or _default_match
+    return SelectorConfig(
+        title="Select syntax theme",
+        items=[
+            SelectorItem(
+                value=theme,
+                label=theme,
+                is_current=matches(theme, current_theme),
+            )
+            for theme in available_themes
+        ],
+        on_change=on_preview,
+    )
+
+
+async def run_code_theme_selector(
+    current_theme: str,
+    available_themes: list[str],
+    on_preview: Callable[[str], None] | None = None,
+    *,
+    theme_matches_current: Callable[[str, str], bool] | None = None,
+) -> str | None:
+    return await run_selector(
+        _build_code_theme_config(
+            current_theme,
+            available_themes,
+            on_preview,
+            theme_matches_current=theme_matches_current,
+        )
+    )