pythinker-code 0.8.0__py3-none-any.whl

pythinker_code/ui/shell/components/diff.py

@@ -0,0 +1,308 @@
+"""Pythinker diff component.
+
+
+plus the diff-string generator from ``edit-diff.ts``.
+
+Two entry points:
+
+* :func:`compute_edit_diff_string` — given ``old_text`` / ``new_text``,
+  produce Pythinker's per-line diff format (``+123 content``, ``-123 content``,
+  `` 123 content``, with `` ... `` skip markers).
+* :func:`render_diff` — colorize a Pythinker-format diff string into a Rich
+  ``Text`` (red removed, green added, dim context, with intra-line word
+  highlighting on single-line edits).
+"""
+
+from __future__ import annotations
+
+import difflib
+import re
+from dataclasses import dataclass
+
+from rich.style import Style as RichStyle
+from rich.text import Text
+
+from pythinker_code.ui.theme import get_diff_colors, tui_rich_style
+
+__all__ = [
+    "EditDiffResult",
+    "compute_edit_diff_string",
+    "render_diff",
+]
+
+_DEFAULT_CONTEXT_LINES = 3
+_TAB_REPLACEMENT = "   "
+_DIFF_LINE_RE = re.compile(r"^([+\-\s])(\s*\d*)\s(.*)$")
+
+
+@dataclass(frozen=True, slots=True)
+class EditDiffResult:
+    """Output of :func:`compute_edit_diff_string`."""
+
+    diff: str
+    first_changed_line: int | None
+
+
+def _replace_tabs(text: str) -> str:
+    return text.replace("\t", _TAB_REPLACEMENT)
+
+
+def compute_edit_diff_string(
+    old_text: str,
+    new_text: str,
+    *,
+    context_lines: int = _DEFAULT_CONTEXT_LINES,
+) -> EditDiffResult:
+    """Build Pythinker's custom diff format from ``old_text``/``new_text``.
+
+    Format per line:
+
+    * ``+<n> <content>`` — added line at new file line ``n``
+    * ``-<n> <content>`` — removed line at old file line ``n``
+    * `` <n> <content>`` — context line
+    * `` <pad> ...``   — collapsed-context marker
+
+    Returns ``("", None)`` when the texts are identical.
+    """
+    if old_text == new_text:
+        return EditDiffResult(diff="", first_changed_line=None)
+
+    old_lines = old_text.split("\n")
+    new_lines = new_text.split("\n")
+    line_num_width = max(2, len(str(max(len(old_lines), len(new_lines)))))
+
+    matcher = difflib.SequenceMatcher(None, old_lines, new_lines, autojunk=False)
+    output: list[str] = []
+    old_lineno = 1
+    new_lineno = 1
+    first_changed: int | None = None
+    last_was_change = False
+    opcodes = matcher.get_opcodes()
+
+    def _pad(n: int) -> str:
+        return str(n).rjust(line_num_width)
+
+    def _blank_pad() -> str:
+        return " " * line_num_width
+
+    for idx, (tag, i1, i2, j1, j2) in enumerate(opcodes):
+        if tag in ("replace", "delete", "insert"):
+            if first_changed is None:
+                first_changed = new_lineno
+            for line in old_lines[i1:i2] if tag != "insert" else []:
+                output.append(f"-{_pad(old_lineno)} {line}")
+                old_lineno += 1
+            for line in new_lines[j1:j2] if tag != "delete" else []:
+                output.append(f"+{_pad(new_lineno)} {line}")
+                new_lineno += 1
+            last_was_change = True
+            continue
+
+        # tag == "equal" — context block.
+        block = old_lines[i1:i2]
+        next_change = idx < len(opcodes) - 1 and opcodes[idx + 1][0] != "equal"
+        leading = last_was_change
+        trailing = next_change
+
+        if leading and trailing:
+            if len(block) <= context_lines * 2:
+                for line in block:
+                    output.append(f" {_pad(old_lineno)} {line}")
+                    old_lineno += 1
+                    new_lineno += 1
+            else:
+                head = block[:context_lines]
+                tail = block[-context_lines:]
+                skipped = len(block) - len(head) - len(tail)
+                for line in head:
+                    output.append(f" {_pad(old_lineno)} {line}")
+                    old_lineno += 1
+                    new_lineno += 1
+                output.append(f" {_blank_pad()} ...")
+                old_lineno += skipped
+                new_lineno += skipped
+                for line in tail:
+                    output.append(f" {_pad(old_lineno)} {line}")
+                    old_lineno += 1
+                    new_lineno += 1
+        elif leading:
+            shown = block[:context_lines]
+            skipped = len(block) - len(shown)
+            for line in shown:
+                output.append(f" {_pad(old_lineno)} {line}")
+                old_lineno += 1
+                new_lineno += 1
+            if skipped > 0:
+                output.append(f" {_blank_pad()} ...")
+                old_lineno += skipped
+                new_lineno += skipped
+        elif trailing:
+            skipped = max(0, len(block) - context_lines)
+            if skipped > 0:
+                output.append(f" {_blank_pad()} ...")
+                old_lineno += skipped
+                new_lineno += skipped
+            for line in block[skipped:]:
+                output.append(f" {_pad(old_lineno)} {line}")
+                old_lineno += 1
+                new_lineno += 1
+        else:
+            old_lineno += len(block)
+            new_lineno += len(block)
+
+        last_was_change = False
+
+    return EditDiffResult(diff="\n".join(output), first_changed_line=first_changed)
+
+
+def _parse_diff_line(line: str) -> tuple[str, str, str] | None:
+    match = _DIFF_LINE_RE.match(line)
+    if not match:
+        return None
+    return match.group(1), match.group(2), match.group(3)
+
+
+def _intra_line_diff(old_content: str, new_content: str) -> tuple[Text, Text]:
+    """Word-level inverse highlighting on changed tokens (the same behavior).
+
+    Returns ``(removed_text, added_text)`` already styled (with the inverse
+    bit set on tokens that differ), but *not* yet wrapped in red/green —
+    callers add the row-level style.
+    """
+    inverse = RichStyle(reverse=True)
+
+    def _tokenize(s: str) -> list[str]:
+        return re.findall(r"\s+|\S+", s)
+
+    old_tokens = _tokenize(old_content)
+    new_tokens = _tokenize(new_content)
+    matcher = difflib.SequenceMatcher(None, old_tokens, new_tokens, autojunk=False)
+    removed = Text()
+    added = Text()
+    first_removed = True
+    first_added = True
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == "equal":
+            piece = "".join(old_tokens[i1:i2])
+            removed.append(piece)
+            added.append(piece)
+            if piece.strip():
+                first_removed = False
+                first_added = False
+            continue
+        # delete / insert / replace
+        if tag in ("delete", "replace"):
+            piece = "".join(old_tokens[i1:i2])
+            if first_removed:
+                stripped = piece.lstrip()
+                leading = piece[: len(piece) - len(stripped)]
+                if leading:
+                    removed.append(leading)
+                if stripped:
+                    removed.append(stripped, style=inverse)
+                if stripped:
+                    first_removed = False
+            else:
+                removed.append(piece, style=inverse)
+        if tag in ("insert", "replace"):
+            piece = "".join(new_tokens[j1:j2])
+            if first_added:
+                stripped = piece.lstrip()
+                leading = piece[: len(piece) - len(stripped)]
+                if leading:
+                    added.append(leading)
+                if stripped:
+                    added.append(stripped, style=inverse)
+                if stripped:
+                    first_added = False
+            else:
+                added.append(piece, style=inverse)
+    return removed, added
+
+
+def render_diff(diff_text: str) -> Text:
+    """Colorize a Pythinker-format diff string.
+
+    ``diff_text`` is whatever :func:`compute_edit_diff_string` produced (or
+    any string in the same format). Lines that don't match the prefix
+    pattern are rendered as dim context.
+    """
+    if not diff_text:
+        return Text("")
+
+    colors = get_diff_colors()
+    added_style = tui_rich_style("tool_diff_added") + colors.add_bg
+    removed_style = tui_rich_style("tool_diff_removed") + colors.del_bg
+    context_style = tui_rich_style("tool_diff_context")
+
+    out = Text()
+    lines = diff_text.split("\n")
+    i = 0
+    first = True
+
+    def _newline() -> None:
+        nonlocal first
+        if not first:
+            out.append("\n")
+        first = False
+
+    while i < len(lines):
+        line = lines[i]
+        parsed = _parse_diff_line(line)
+        if parsed is None:
+            _newline()
+            out.append(line, style=context_style)
+            i += 1
+            continue
+        prefix, line_num, content = parsed
+
+        if prefix == "-":
+            removed_block: list[tuple[str, str]] = []
+            while i < len(lines):
+                p = _parse_diff_line(lines[i])
+                if p is None or p[0] != "-":
+                    break
+                removed_block.append((p[1], p[2]))
+                i += 1
+            added_block: list[tuple[str, str]] = []
+            while i < len(lines):
+                p = _parse_diff_line(lines[i])
+                if p is None or p[0] != "+":
+                    break
+                added_block.append((p[1], p[2]))
+                i += 1
+
+            if len(removed_block) == 1 and len(added_block) == 1:
+                rln, rcontent = removed_block[0]
+                aln, acontent = added_block[0]
+                rem_inner, add_inner = _intra_line_diff(
+                    _replace_tabs(rcontent),
+                    _replace_tabs(acontent),
+                )
+                _newline()
+                row = Text(f"-{rln} ", style=removed_style)
+                row.append_text(rem_inner)
+                row.stylize(removed_style)
+                out.append_text(row)
+                _newline()
+                row = Text(f"+{aln} ", style=added_style)
+                row.append_text(add_inner)
+                row.stylize(added_style)
+                out.append_text(row)
+            else:
+                for ln, content in removed_block:
+                    _newline()
+                    out.append(f"-{ln} {_replace_tabs(content)}", style=removed_style)
+                for ln, content in added_block:
+                    _newline()
+                    out.append(f"+{ln} {_replace_tabs(content)}", style=added_style)
+        elif prefix == "+":
+            _newline()
+            out.append(f"+{line_num} {_replace_tabs(content)}", style=added_style)
+            i += 1
+        else:
+            _newline()
+            out.append(f" {line_num} {_replace_tabs(content)}", style=context_style)
+            i += 1
+
+    return out

pythinker_code/ui/shell/components/footer.py

@@ -0,0 +1,231 @@
+"""Pythinker footer component.
+
+
+plus its data provider: a two- or three-line status block with cwd/git/session
+on top, usage stats + context%/model on the right, and optional extension
+status lines.
+
+This module is intentionally state-source-agnostic. Callers populate a
+:class:`FooterState` dataclass from wherever the truth lives (Pythinker's
+session manager, soul state, runtime config) and pass it to
+:func:`render_footer`. Wiring into ``prompt.py`` is a separate task.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+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 truncate_to_width
+from pythinker_code.ui.theme import tui_rich_style
+
+__all__ = [
+    "FooterState",
+    "FooterUsage",
+    "format_tokens",
+    "render_footer",
+]
+
+
+_WHITESPACE_RE = re.compile(r"[\r\n\t]+")
+_MULTI_SPACE_RE = re.compile(r" +")
+
+
+@dataclass(frozen=True, slots=True)
+class FooterUsage:
+    """Cumulative usage stats over the session.
+
+    Mirrors the ``message.usage`` aggregate. All counts are token totals.
+    ``cost_total`` is in dollars (equivalent to summing message-level cost.total).
+    """
+
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_read_tokens: int = 0
+    cache_write_tokens: int = 0
+    cost_total: float = 0.0
+
+
+@dataclass(frozen=True, slots=True)
+class FooterState:
+    """Inputs for :func:`render_footer`.
+
+    Attributes:
+        cwd: Working directory (will be home-shortened with ``~``).
+        git_branch: Current branch name, or ``None`` to omit.
+        session_name: Friendly session label, or ``None``.
+        usage: Cumulative usage; pass an empty :class:`FooterUsage` to
+            suppress all token counters.
+        context_percent: ``0..100`` percentage of context window used, or
+            ``None`` if unknown post-compaction.
+        context_window: Total context window size for the active model.
+        auto_compact_enabled: Adds the ``(auto)`` suffix on the context %.
+        model_id: Display name of the active model, or ``None``.
+        model_provider: Provider id, only shown when ``show_provider`` is
+            ``True`` and there's room.
+        show_provider: Set to ``True`` when more than one provider is
+            available — keeps the footer terse otherwise.
+        thinking_level: ``"off" | "low" | "medium" | "high"`` or ``None``;
+            renders as ``model • <level>`` when set.
+        oauth_subscription: Adds ``(sub)`` next to the cost.
+        extension_statuses: Optional map of extension id → status text.
+            Sorted alphabetically and emitted as a third line.
+    """
+
+    cwd: str
+    git_branch: str | None = None
+    session_name: str | None = None
+    usage: FooterUsage = field(default_factory=FooterUsage)
+    context_percent: float | None = None
+    context_window: int = 0
+    auto_compact_enabled: bool = True
+    model_id: str | None = None
+    model_provider: str | None = None
+    show_provider: bool = False
+    thinking_level: str | None = None
+    oauth_subscription: bool = False
+    extension_statuses: dict[str, str] = field(default_factory=dict[str, str])
+
+
+def format_tokens(count: int) -> str:
+    """Pythinker's compact token formatter: ``1234`` → ``1.2k``."""
+    if count < 1_000:
+        return str(count)
+    if count < 10_000:
+        return f"{count / 1000:.1f}k"
+    if count < 1_000_000:
+        return f"{round(count / 1000)}k"
+    if count < 10_000_000:
+        return f"{count / 1_000_000:.1f}M"
+    return f"{round(count / 1_000_000)}M"
+
+
+def _sanitize(text: str) -> str:
+    return _MULTI_SPACE_RE.sub(" ", _WHITESPACE_RE.sub(" ", text)).strip()
+
+
+def _shorten_home(cwd: str) -> str:
+    home = os.environ.get("HOME") or os.environ.get("USERPROFILE")
+    if not home:
+        return cwd
+    try:
+        rel = Path(cwd).relative_to(home)
+        rel_str = str(rel)
+        return "~" if rel_str == "." else f"~/{rel_str}"
+    except ValueError:
+        return cwd
+
+
+def _build_pwd_line(state: FooterState) -> str:
+    pwd = _shorten_home(state.cwd)
+    if state.git_branch:
+        pwd = f"{pwd} ({state.git_branch})"
+    if state.session_name:
+        pwd = f"{pwd} • {state.session_name}"
+    return pwd
+
+
+def _build_stats_left(state: FooterState) -> tuple[Text, str]:
+    """Return ``(rendered_left_text, plain_left_text)``.
+
+    The plain text is needed for width math when laying out the right side.
+    """
+    parts: list[tuple[str, str]] = []  # (text, token)
+    u = state.usage
+    if u.input_tokens:
+        parts.append((f"↑{format_tokens(u.input_tokens)}", "dim"))
+    if u.output_tokens:
+        parts.append((f"↓{format_tokens(u.output_tokens)}", "dim"))
+    if u.cache_read_tokens:
+        parts.append((f"R{format_tokens(u.cache_read_tokens)}", "dim"))
+    if u.cache_write_tokens:
+        parts.append((f"W{format_tokens(u.cache_write_tokens)}", "dim"))
+    if u.cost_total or state.oauth_subscription:
+        sub = " (sub)" if state.oauth_subscription else ""
+        parts.append((f"${u.cost_total:.3f}{sub}", "dim"))
+
+    auto = " (auto)" if state.auto_compact_enabled else ""
+    if state.context_percent is None:
+        ctx_text = f"?/{format_tokens(state.context_window)}{auto}"
+        ctx_token = "dim"
+    else:
+        ctx_text = f"{state.context_percent:.1f}%/{format_tokens(state.context_window)}{auto}"
+        if state.context_percent > 90:
+            ctx_token = "error"
+        elif state.context_percent > 70:
+            ctx_token = "warning"
+        else:
+            ctx_token = "dim"
+    parts.append((ctx_text, ctx_token))
+
+    rendered = Text()
+    plain_parts: list[str] = []
+    for i, (text, token) in enumerate(parts):
+        if i:
+            rendered.append(" ", style=tui_rich_style("dim"))
+            plain_parts.append(" ")
+        rendered.append(text, style=tui_rich_style(token))
+        plain_parts.append(text)
+    return rendered, "".join(plain_parts)
+
+
+def _build_right_side(state: FooterState, *, plain_left_width: int, width: int) -> str:
+    if not state.model_id:
+        return ""
+    right = state.model_id
+    if state.thinking_level:
+        right = f"{state.model_id} • {state.thinking_level}"
+    if state.show_provider and state.model_provider:
+        candidate = f"({state.model_provider}) {right}"
+        if plain_left_width + 2 + len(candidate) <= width:
+            right = candidate
+    return right
+
+
+def render_footer(state: FooterState, *, width: int) -> RenderableType:
+    """Build the multi-line footer renderable for *state* at *width*."""
+    dim = tui_rich_style("dim")
+
+    pwd = _build_pwd_line(state)
+    pwd_truncated = truncate_to_width(pwd, max(1, width))
+    pwd_text = Text(pwd_truncated, style=dim)
+
+    stats_left_text, stats_left_plain = _build_stats_left(state)
+    if len(stats_left_plain) > width:
+        truncated = truncate_to_width(stats_left_plain, width)
+        stats_left_text = Text(truncated, style=dim)
+        stats_left_plain = truncated
+
+    right = _build_right_side(state, plain_left_width=len(stats_left_plain), width=width)
+    if right:
+        space = max(2, width - len(stats_left_plain) - len(right))
+        # If even the minimum 2-space gap plus right doesn't fit, truncate right.
+        if len(stats_left_plain) + 2 + len(right) > width:
+            avail = width - len(stats_left_plain) - 2
+            if avail > 0:
+                right = truncate_to_width(right, avail, ellipsis="")
+                space = max(0, width - len(stats_left_plain) - len(right))
+            else:
+                right = ""
+                space = 0
+        stats_line = Text()
+        stats_line.append_text(stats_left_text)
+        if right:
+            stats_line.append(" " * space, style=dim)
+            stats_line.append(right, style=dim + RichStyle(bold=False))
+    else:
+        stats_line = stats_left_text
+
+    children: list[RenderableType] = [pwd_text, stats_line]
+    if state.extension_statuses:
+        ordered = sorted(state.extension_statuses.items(), key=lambda kv: kv[0])
+        joined = " ".join(_sanitize(text) for _, text in ordered)
+        ext = truncate_to_width(joined, width)
+        children.append(Text(ext, style=dim))
+    return Group(*children)

pythinker_code/ui/shell/components/key_hints.py

@@ -0,0 +1,27 @@
+"""Helpers for formatting keybinding hints in Pythinker status lines."""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+
+def raw_key_hint(key: str, description: str) -> Text:
+    """Format ``Esc cancel``-style hint with a raw key string.
+
+    Use when no semantic keybinding is registered yet (or the binding is
+    fixed at the OS/terminal level, e.g. ``Esc``).
+    """
+    out = Text()
+    out.append(key, style="grey50")
+    out.append(f" {description}", style="grey39")
+    return out
+
+
+def key_hint(key: str, description: str) -> Text:
+    """Format a key hint. Currently aliased to :func:`raw_key_hint`.
+
+    Reserved for a future keymap registry — once Phase 10 lands, this will
+    look up *key* in a central registry instead of taking it verbatim. The
+    public API is split now so call sites don't churn later.
+    """
+    return raw_key_hint(key, description)