pythinker-code 2.0.0__py3-none-any.whl

pythinker_code/ui/shell/console.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import os
+import pydoc
+import re
+
+from rich.console import Console, PagerContext, RenderableType
+from rich.pager import Pager
+from rich.theme import Theme
+
+NEUTRAL_MARKDOWN_THEME = Theme(
+    {
+        "markdown.paragraph": "none",
+        "markdown.block_quote": "none",
+        "markdown.hr": "none",
+        "markdown.list": "none",
+        "markdown.item": "none",
+        "markdown.item.bullet": "none",
+        "markdown.item.number": "none",
+        "markdown.link": "none",
+        "markdown.link_url": "none",
+        "markdown.h1": "none",
+        "markdown.h1.border": "none",
+        "markdown.h2": "none",
+        "markdown.h3": "none",
+        "markdown.h4": "none",
+        "markdown.h5": "none",
+        "markdown.h6": "none",
+        "markdown.h7": "none",
+        "markdown.em": "none",
+        "markdown.emph": "none",
+        "markdown.strong": "none",
+        "markdown.s": "none",
+        "markdown.code": "none",
+        "markdown.code_block": "none",
+        "status.spinner": "none",
+    },
+    inherit=True,
+)
+
+_NEUTRAL_MARKDOWN_THEME = NEUTRAL_MARKDOWN_THEME
+
+
+class _PythinkerPager(Pager):
+    """Pager that ignores MANPAGER to avoid garbled output.
+
+    ``pydoc.getpager()`` reads ``MANPAGER`` before ``PAGER``.  When the user
+    sets ``MANPAGER`` to a man-specific pipeline (e.g.
+    ``sh -c 'col -bx | bat -l man -p'``), that pipeline mangles the ANSI
+    rich-text we emit.  This pager strips ``MANPAGER`` from the subprocess
+    environment so only ``PAGER`` (or the default ``less``) is used.
+    """
+
+    def show(self, content: str) -> None:
+        saved = os.environ.pop("MANPAGER", None)
+        try:
+            pydoc.pager(content)
+        finally:
+            if saved is not None:
+                os.environ["MANPAGER"] = saved
+
+
+class _PythinkerConsole(Console):
+    """Console subclass that defaults to :class:`_PythinkerPager`."""
+
+    def pager(
+        self,
+        pager: Pager | None = None,
+        styles: bool = False,
+        links: bool = False,
+    ) -> PagerContext:
+        if pager is None:
+            pager = _PythinkerPager()
+        return super().pager(pager=pager, styles=styles, links=links)
+
+
+console = _PythinkerConsole(highlight=False, theme=NEUTRAL_MARKDOWN_THEME)
+
+
+# Matches OSC 8 hyperlink open/close markers emitted by Rich's Style(link=...).
+# Format: ESC ] 8 ; <params> ; <uri> ST   where ST is ESC \ or BEL (\x07).
+# prompt_toolkit's ANSI parser does not understand OSC 8 and renders the raw
+# escape bytes as visible garbage (e.g. "8;id=391551;https://…").  We wrap each
+# marker in \001…\002 so prompt_toolkit treats it as a ZeroWidthEscape and
+# passes it through to the terminal via write_raw, preserving clickable links.
+_OSC8_RE = re.compile(r"\x1b\]8;[^\x07\x1b]*(?:\x1b\\|\x07)")
+
+
+def _wrap_osc8_as_zero_width(m: re.Match[str]) -> str:
+    """Wrap an OSC 8 marker in \\001…\\002 for prompt_toolkit ZeroWidthEscape."""
+    return f"\x01{m.group(0)}\x02"
+
+
+def render_to_ansi(renderable: RenderableType, *, columns: int) -> str:
+    """Render a Rich renderable to an ANSI string for prompt_toolkit integration."""
+    from io import StringIO
+
+    width = max(20, columns)
+    buf = StringIO()
+    temp = Console(
+        file=buf,
+        force_terminal=True,
+        width=width,
+        theme=NEUTRAL_MARKDOWN_THEME,
+        highlight=False,
+    )
+    temp.print(renderable, end="")
+    result = buf.getvalue()
+    return _OSC8_RE.sub(_wrap_osc8_as_zero_width, result)

pythinker_code/ui/shell/debug.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from pythinker_core.message import Message
+from rich.console import Group, RenderableType
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.syntax import Syntax
+from rich.text import Text
+
+from pythinker_code.soul.pythinkersoul import PythinkerSoul
+from pythinker_code.ui.shell.console import console
+from pythinker_code.ui.shell.slash import registry
+from pythinker_code.wire.types import (
+    AudioURLPart,
+    ContentPart,
+    ImageURLPart,
+    TextPart,
+    ThinkPart,
+    ToolCall,
+    VideoURLPart,
+)
+
+if TYPE_CHECKING:
+    from pythinker_code.ui.shell import Shell
+
+
+def _format_content_part(part: ContentPart) -> Text | Panel | Group:
+    """Format a single content part."""
+    match part:
+        case TextPart(text=text):
+            # Check if it looks like a system tag
+            if text.strip().startswith("<system>") and text.strip().endswith("</system>"):
+                return Panel(
+                    text.strip()[8:-9].strip(),
+                    title="[dim]system[/dim]",
+                    border_style="dim yellow",
+                    padding=(0, 1),
+                )
+            return Text(text, style="white")
+
+        case ThinkPart(think=think):
+            return Panel(
+                think,
+                title="[dim]thinking[/dim]",
+                border_style="dim cyan",
+                padding=(0, 1),
+            )
+
+        case ImageURLPart(image_url=img):
+            url_display = img.url[:80] + "..." if len(img.url) > 80 else img.url
+            return Text(f"[Image] {url_display}", style="blue")
+
+        case AudioURLPart(audio_url=audio):
+            url_display = audio.url[:80] + "..." if len(audio.url) > 80 else audio.url
+            id_text = f" (id: {audio.id})" if audio.id else ""
+            return Text(f"[Audio{id_text}] {url_display}", style="blue")
+
+        case VideoURLPart(video_url=video):
+            url_display = video.url[:80] + "..." if len(video.url) > 80 else video.url
+            return Text(f"[Video] {url_display}", style="blue")
+
+        case _:
+            return Text(f"[Unknown content type: {type(part).__name__}]", style="red")
+
+
+def _format_tool_call(tool_call: ToolCall) -> Panel:
+    """Format a tool call."""
+    args = tool_call.function.arguments or "{}"
+    try:
+        args_formatted = json.dumps(json.loads(args, strict=False), indent=2)
+        args_syntax = Syntax(args_formatted, "json", theme="monokai", padding=(0, 1))
+    except json.JSONDecodeError:
+        args_syntax = Text(args, style="red")
+
+    content = Group(
+        Text(f"Function: {tool_call.function.name}", style="bold cyan"),
+        Text(f"Call ID: {tool_call.id}", style="dim"),
+        Text("Arguments:", style="bold"),
+        args_syntax,
+    )
+
+    return Panel(
+        content,
+        title="[bold yellow]Tool Call[/bold yellow]",
+        border_style="yellow",
+        padding=(0, 1),
+    )
+
+
+def _format_message(msg: Message, index: int) -> Panel:
+    """Format a single message."""
+    # Role styling
+    role_colors = {
+        "system": "magenta",
+        "developer": "magenta",
+        "user": "green",
+        "assistant": "blue",
+        "tool": "yellow",
+    }
+    role_color = role_colors.get(msg.role, "white")
+    role_text = f"[bold {role_color}]{msg.role.upper()}[/bold {role_color}]"
+
+    # Add name if present
+    if msg.name:
+        role_text += f" [dim]({msg.name})[/dim]"
+
+    # Add tool call ID for tool messages
+    if msg.tool_call_id:
+        role_text += f" [dim]→ {msg.tool_call_id}[/dim]"
+
+    # Format content
+    content_items: list[RenderableType] = []
+
+    for part in msg.content:
+        formatted = _format_content_part(part)
+        content_items.append(formatted)
+
+    # Add tool calls if present
+    if msg.tool_calls:
+        if content_items:
+            content_items.append(Text())  # Empty line
+        for tool_call in msg.tool_calls:
+            content_items.append(_format_tool_call(tool_call))
+
+    # Combine all content
+    if not content_items:
+        content_items.append(Text("[empty message]", style="dim italic"))
+
+    group = Group(*content_items)
+
+    # Create panel
+    title = f"#{index + 1} {role_text}"
+    if msg.partial:
+        title += " [dim italic](partial)[/dim italic]"
+
+    return Panel(
+        group,
+        title=title,
+        border_style=role_color,
+        padding=(0, 1),
+    )
+
+
+@registry.command
+def debug(app: Shell, args: str):
+    """Debug the context"""
+    assert isinstance(app.soul, PythinkerSoul)
+
+    context = app.soul.context
+    history = context.history
+
+    if not history:
+        console.print(
+            Panel(
+                "Context is empty - no messages yet",
+                border_style="yellow",
+                padding=(1, 2),
+            )
+        )
+        return
+
+    # Build the debug output
+    output_items = [
+        Panel(
+            Group(
+                Text(f"Total messages: {len(history)}", style="bold"),
+                Text(f"Token count: {context.token_count:,}", style="bold"),
+                Text(f"Checkpoints: {context.n_checkpoints}", style="bold"),
+                Text(f"Trajectory: {context.file_backend}", style="dim"),
+            ),
+            title="[bold]Context Info[/bold]",
+            border_style="cyan",
+            padding=(0, 1),
+        ),
+        Rule(style="dim"),
+    ]
+
+    # Add all messages
+    for idx, msg in enumerate(history):
+        output_items.append(_format_message(msg, idx))
+
+    # Display using rich pager
+    display_group = Group(*output_items)
+
+    # Use pager to display
+    with console.pager(styles=True):
+        console.print(display_group)

pythinker_code/ui/shell/echo.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from pythinker_core.message import Message
+from rich.text import Text
+
+from pythinker_code.ui.shell.prompt import PROMPT_SYMBOL
+from pythinker_code.utils.message import message_stringify
+
+
+def render_user_echo(message: Message) -> Text:
+    """Render a user message as literal shell transcript text."""
+    return Text(f"{PROMPT_SYMBOL} {message_stringify(message)}")
+
+
+def render_user_echo_text(text: str) -> Text:
+    """Render the local prompt text exactly as the user saw it in the buffer."""
+    return Text(f"{PROMPT_SYMBOL} {text}")

pythinker_code/ui/shell/export_import.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from pythinker_host.path import HostPath
+
+from pythinker_code.ui.shell.console import console
+from pythinker_code.ui.shell.slash import ensure_pythinker_soul, registry, shell_mode_registry
+from pythinker_code.utils.export import is_sensitive_file
+from pythinker_code.utils.path import sanitize_cli_path, shorten_home
+from pythinker_code.wire.types import TurnBegin, TurnEnd
+
+if TYPE_CHECKING:
+    from pythinker_code.ui.shell import Shell
+
+
+# ---------------------------------------------------------------------------
+# /export command
+# ---------------------------------------------------------------------------
+
+
+@registry.command
+@shell_mode_registry.command
+async def export(app: Shell, args: str):
+    """Export current session context to a markdown file"""
+    from pythinker_code.utils.export import perform_export
+
+    soul = ensure_pythinker_soul(app)
+    if soul is None:
+        return
+
+    session = soul.runtime.session
+    result = await perform_export(
+        history=list(soul.context.history),
+        session_id=session.id,
+        work_dir=str(session.work_dir),
+        token_count=soul.context.token_count,
+        args=args,
+        default_dir=Path(str(session.work_dir)),
+    )
+    if isinstance(result, str):
+        console.print(f"[yellow]{result}[/yellow]")
+        return
+
+    output, count = result
+    from pythinker_code.telemetry import track
+
+    track("export")
+    display = shorten_home(HostPath(str(output)))
+    console.print(f"[green]Exported {count} messages to {display}[/green]")
+    console.print(
+        "[yellow]Note: The exported file may contain sensitive information. "
+        "Please be cautious when sharing it externally.[/yellow]"
+    )
+
+
+# ---------------------------------------------------------------------------
+# /import command
+# ---------------------------------------------------------------------------
+
+
+@registry.command(name="import")
+@shell_mode_registry.command(name="import")
+async def import_context(app: Shell, args: str):
+    """Import context from a file or session ID"""
+    from pythinker_code.utils.export import perform_import
+
+    soul = ensure_pythinker_soul(app)
+    if soul is None:
+        return
+
+    target = sanitize_cli_path(args)
+    if not target:
+        console.print("[yellow]Usage: /import <file_path or session_id>[/yellow]")
+        return
+
+    session = soul.runtime.session
+    raw_max_context_size = (
+        soul.runtime.llm.max_context_size if soul.runtime.llm is not None else None
+    )
+    max_context_size = (
+        raw_max_context_size
+        if isinstance(raw_max_context_size, int) and raw_max_context_size > 0
+        else None
+    )
+    result = await perform_import(
+        target=target,
+        current_session_id=session.id,
+        work_dir=session.work_dir,
+        context=soul.context,
+        max_context_size=max_context_size,
+    )
+    if isinstance(result, str):
+        console.print(f"[red]{result}[/red]")
+        return
+
+    source_desc, content_len = result
+    from pythinker_code.telemetry import track
+
+    track("import")
+
+    # Write to wire file so the import appears in session replay
+    await soul.wire_file.append_message(
+        TurnBegin(user_input=f"[Imported context from {source_desc}]")
+    )
+    await soul.wire_file.append_message(TurnEnd())
+
+    console.print(
+        f"[green]Imported context from {source_desc} "
+        f"({content_len} chars) into current session.[/green]"
+    )
+    if source_desc.startswith("file") and is_sensitive_file(Path(target).name):
+        console.print(
+            "[yellow]Warning: This file may contain secrets (API keys, tokens, credentials). "
+            "The content is now part of your session context.[/yellow]"
+        )