pythinker-code 0.8.0__py3-none-any.whl

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]"
+        )

pythinker_code/ui/shell/keyboard.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+import threading
+import time
+from collections.abc import AsyncGenerator, Callable
+from enum import Enum, auto
+
+from pythinker_code.utils.aioqueue import Queue
+
+
+class KeyEvent(Enum):
+    UP = auto()
+    DOWN = auto()
+    LEFT = auto()
+    RIGHT = auto()
+    ENTER = auto()
+    ESCAPE = auto()
+    TAB = auto()
+    SPACE = auto()
+    CTRL_E = auto()
+    NUM_1 = auto()
+    NUM_2 = auto()
+    NUM_3 = auto()
+    NUM_4 = auto()
+    NUM_5 = auto()
+    NUM_6 = auto()
+
+
+class KeyboardListener:
+    def __init__(self) -> None:
+        self._queue = Queue[KeyEvent]()
+        self._cancel_event = threading.Event()
+        self._pause_event = threading.Event()
+        self._paused_event = threading.Event()
+        self._listener: threading.Thread | None = None
+        self._loop: asyncio.AbstractEventLoop | None = None
+
+    async def start(self) -> None:
+        if self._listener is not None:
+            return
+        self._loop = asyncio.get_running_loop()
+
+        def emit(event: KeyEvent) -> None:
+            if self._loop is None:
+                return
+            self._loop.call_soon_threadsafe(self._queue.put_nowait, event)
+
+        self._listener = threading.Thread(
+            target=_listen_for_keyboard_thread,
+            args=(self._cancel_event, self._pause_event, self._paused_event, emit),
+            name="pythinker-code-keyboard-listener",
+            daemon=True,
+        )
+        self._listener.start()
+
+    async def stop(self) -> None:
+        self._cancel_event.set()
+        self._pause_event.clear()
+        if self._listener and self._listener.is_alive():
+            await asyncio.to_thread(self._listener.join)
+
+    def _pause_sync(self) -> None:
+        self._pause_event.set()
+        self._paused_event.wait()
+
+    async def pause(self) -> None:
+        await asyncio.to_thread(self._pause_sync)
+
+    def _resume_sync(self) -> None:
+        self._pause_event.clear()
+        while self._paused_event.is_set() and not self._cancel_event.is_set():
+            time.sleep(0.01)
+
+    async def resume(self) -> None:
+        await asyncio.to_thread(self._resume_sync)
+
+    async def get(self) -> KeyEvent:
+        return await self._queue.get()
+
+
+async def listen_for_keyboard() -> AsyncGenerator[KeyEvent]:
+    listener = KeyboardListener()
+    await listener.start()
+
+    try:
+        while True:
+            yield await listener.get()
+    finally:
+        await listener.stop()
+
+
+def _listen_for_keyboard_thread(
+    cancel: threading.Event,
+    pause: threading.Event,
+    paused: threading.Event,
+    emit: Callable[[KeyEvent], None],
+) -> None:
+    if sys.platform == "win32":
+        _listen_for_keyboard_windows(cancel, pause, paused, emit)
+    else:
+        _listen_for_keyboard_unix(cancel, pause, paused, emit)
+
+
+def _listen_for_keyboard_unix(
+    cancel: threading.Event,
+    pause: threading.Event,
+    paused: threading.Event,
+    emit: Callable[[KeyEvent], None],
+) -> None:
+    if sys.platform == "win32":
+        raise RuntimeError("Unix keyboard listener requires a non-Windows platform")
+
+    import termios
+
+    fd = sys.stdin.fileno()
+    oldterm = termios.tcgetattr(fd)
+    rawattr = termios.tcgetattr(fd)
+    rawattr[3] = rawattr[3] & ~termios.ICANON & ~termios.ECHO
+    rawattr[6][termios.VMIN] = 0
+    rawattr[6][termios.VTIME] = 0
+    raw_enabled = False
+
+    def enable_raw() -> None:
+        nonlocal raw_enabled
+        if raw_enabled:
+            return
+        termios.tcsetattr(fd, termios.TCSANOW, rawattr)
+        raw_enabled = True
+
+    def disable_raw() -> None:
+        nonlocal raw_enabled
+        if not raw_enabled:
+            return
+        termios.tcsetattr(fd, termios.TCSANOW, oldterm)
+        raw_enabled = False
+
+    enable_raw()
+
+    try:
+        while not cancel.is_set():
+            if pause.is_set():
+                disable_raw()
+                paused.set()
+                time.sleep(0.01)
+                continue
+            if paused.is_set():
+                paused.clear()
+                enable_raw()
+
+            try:
+                c = sys.stdin.buffer.read(1)
+            except (OSError, ValueError):
+                c = b""
+
+            if not c:
+                if cancel.is_set():
+                    break
+                time.sleep(0.01)
+                continue
+
+            if c == b"\x1b":
+                sequence = c
+                for _ in range(2):
+                    if cancel.is_set():
+                        break
+                    try:
+                        fragment = sys.stdin.buffer.read(1)
+                    except (OSError, ValueError):
+                        fragment = b""
+                    if not fragment:
+                        break
+                    sequence += fragment
+                    if sequence in _ARROW_KEY_MAP:
+                        break
+
+                event = _ARROW_KEY_MAP.get(sequence)
+                if event is not None:
+                    emit(event)
+                elif sequence == b"\x1b":
+                    emit(KeyEvent.ESCAPE)
+            elif c in (b"\r", b"\n"):
+                emit(KeyEvent.ENTER)
+            elif c == b" ":
+                emit(KeyEvent.SPACE)
+            elif c == b"\t":
+                emit(KeyEvent.TAB)
+            elif c == b"\x05":  # Ctrl+E
+                emit(KeyEvent.CTRL_E)
+            elif c == b"1":
+                emit(KeyEvent.NUM_1)
+            elif c == b"2":
+                emit(KeyEvent.NUM_2)
+            elif c == b"3":
+                emit(KeyEvent.NUM_3)
+            elif c == b"4":
+                emit(KeyEvent.NUM_4)
+            elif c == b"5":
+                emit(KeyEvent.NUM_5)
+            elif c == b"6":
+                emit(KeyEvent.NUM_6)
+    finally:
+        termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
+
+
+def _listen_for_keyboard_windows(
+    cancel: threading.Event,
+    pause: threading.Event,
+    paused: threading.Event,
+    emit: Callable[[KeyEvent], None],
+) -> None:
+    if sys.platform != "win32":
+        raise RuntimeError("Windows keyboard listener requires a Windows platform")
+
+    import msvcrt
+
+    while not cancel.is_set():
+        if pause.is_set():
+            paused.set()
+            time.sleep(0.01)
+            continue
+        if paused.is_set():
+            paused.clear()
+
+        if msvcrt.kbhit():
+            c = msvcrt.getch()
+
+            # Handle special keys (arrow keys, etc.)
+            if c in (b"\x00", b"\xe0"):
+                # Extended key, read the next byte
+                extended = msvcrt.getch()
+                event = _WINDOWS_KEY_MAP.get(extended)
+                if event is not None:
+                    emit(event)
+            elif c == b"\x1b":
+                sequence = c
+                for _ in range(2):
+                    if cancel.is_set():
+                        break
+                    fragment = msvcrt.getch() if msvcrt.kbhit() else b""
+                    if not fragment:
+                        break
+                    sequence += fragment
+                    if sequence in _ARROW_KEY_MAP:
+                        break
+
+                event = _ARROW_KEY_MAP.get(sequence)
+                if event is not None:
+                    emit(event)
+                elif sequence == b"\x1b":
+                    emit(KeyEvent.ESCAPE)
+            elif c in (b"\r", b"\n"):
+                emit(KeyEvent.ENTER)
+            elif c == b" ":
+                emit(KeyEvent.SPACE)
+            elif c == b"\t":
+                emit(KeyEvent.TAB)
+            elif c == b"\x05":  # Ctrl+E
+                emit(KeyEvent.CTRL_E)
+            elif c == b"1":
+                emit(KeyEvent.NUM_1)
+            elif c == b"2":
+                emit(KeyEvent.NUM_2)
+            elif c == b"3":
+                emit(KeyEvent.NUM_3)
+            elif c == b"4":
+                emit(KeyEvent.NUM_4)
+            elif c == b"5":
+                emit(KeyEvent.NUM_5)
+            elif c == b"6":
+                emit(KeyEvent.NUM_6)
+        else:
+            if cancel.is_set():
+                break
+            time.sleep(0.01)
+
+
+_ARROW_KEY_MAP: dict[bytes, KeyEvent] = {
+    b"\x1b[A": KeyEvent.UP,
+    b"\x1b[B": KeyEvent.DOWN,
+    b"\x1b[C": KeyEvent.RIGHT,
+    b"\x1b[D": KeyEvent.LEFT,
+}
+
+_WINDOWS_KEY_MAP: dict[bytes, KeyEvent] = {
+    b"H": KeyEvent.UP,  # Up arrow
+    b"P": KeyEvent.DOWN,  # Down arrow
+    b"M": KeyEvent.RIGHT,  # Right arrow
+    b"K": KeyEvent.LEFT,  # Left arrow
+}
+
+
+if __name__ == "__main__":
+
+    async def dev_main():
+        async for event in listen_for_keyboard():
+            print(event)
+
+    asyncio.run(dev_main())

pythinker_code/ui/shell/keymap.py

@@ -0,0 +1,84 @@
+"""Minimal Pythinker keybinding registry.
+
+Built-in keybinding registry
+``modes/interactive/components/keybinding-hints.ts`` . the
+full registry lists ~50 identifiers wired across model/session/tree
+selectors, most of which Pythinker doesn't expose yet — we ship only the
+semantic ids we currently use, with a `register_keybinding` hatch so
+extensions or future features can add more without forking this file.
+
+Two surfaces:
+
+* :func:`key_text(name)` returns the printable representation
+  (``"ctrl+e"``, ``"esc"``) — used inline in renderers.
+* :func:`key_hint(name, description)` returns a Rich ``Text`` ready to
+  drop into a card (``"ctrl+e expand"``, dim+muted styled).
+"""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+from pythinker_code.ui.theme import tui_rich_style
+
+__all__ = [
+    "all_keybindings",
+    "key_hint",
+    "key_text",
+    "register_keybinding",
+]
+
+
+# Default registry. Keys are Pythinker semantic ids ("app.tools.expand");
+# values are the key chord(s) the host will dispatch.
+_REGISTRY: dict[str, tuple[str, ...]] = {
+    "app.interrupt": ("esc", "ctrl+c"),
+    "app.exit": ("ctrl+d",),
+    "app.suspend": ("ctrl+z",),
+    "app.tools.expand": ("ctrl+e",),
+    "app.message.followUp": ("alt+enter",),
+    "app.editor.external": ("ctrl+x",),
+    "app.session.new": ("ctrl+n",),
+    "tui.select.cancel": ("esc",),
+    "tui.select.confirm": ("enter",),
+}
+
+
+def register_keybinding(name: str, *keys: str) -> None:
+    """Register or override the key chord(s) for *name*.
+
+    Last writer wins — extensions calling this at startup can replace any
+    builtin binding. Empty *keys* removes the binding entirely.
+    """
+    if not keys:
+        _REGISTRY.pop(name, None)
+        return
+    _REGISTRY[name] = tuple(keys)
+
+
+def all_keybindings() -> dict[str, tuple[str, ...]]:
+    """Return a copy of the full registry — useful for `/keys` overlays."""
+    return dict(_REGISTRY)
+
+
+def key_text(name: str) -> str:
+    """Render the chord(s) bound to *name* as ``"ctrl+e"`` or ``"esc/ctrl+c"``.
+
+    Returns an empty string when *name* is unknown — callers can fall back
+    to a hard-coded label.
+    """
+    keys = _REGISTRY.get(name)
+    if not keys:
+        return ""
+    return "/".join(keys)
+
+
+def key_hint(name: str, description: str) -> Text:
+    """Build a ``"<keys> <description>"`` hint as styled Rich Text."""
+    out = Text()
+    label = key_text(name)
+    if label:
+        out.append(label, style=tui_rich_style("dim"))
+        out.append(" ")
+    out.append(description, style=tui_rich_style("muted"))
+    return out

pythinker_code/ui/shell/mcp_status.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import time
+
+from prompt_toolkit.formatted_text import FormattedText
+from rich.console import Group, RenderableType
+from rich.style import Style
+from rich.text import Text
+
+from pythinker_code.ui.theme import get_mcp_prompt_colors
+from pythinker_code.utils.rich.columns import BulletColumns
+from pythinker_code.wire.types import MCPServerSnapshot, MCPStatusSnapshot
+
+
+def render_mcp_console(snapshot: MCPStatusSnapshot) -> RenderableType:
+    header_text = Text.assemble(
+        ("MCP Servers: ", "bold"),
+        f"{snapshot.connected}/{snapshot.total} connected, {snapshot.tools} tools",
+    )
+    if snapshot.loading:
+        glyph = "●" if int(time.monotonic() / 0.8) % 2 == 0 else " "
+        header = Text(f"{glyph} ", style=Style(color="grey50"))
+        header.append_text(header_text)
+    else:
+        header = header_text
+
+    renderables: list[RenderableType] = [BulletColumns(header)]
+    for server in snapshot.servers:
+        color = _status_color(server.status)
+        server_text = f"[{color}]{server.name}[/{color}]"
+        if server.status == "unauthorized":
+            server_text += (
+                f" [grey50](unauthorized - run: pythinker mcp auth {server.name})[/grey50]"
+            )
+        elif server.status != "connected":
+            server_text += f" [grey50]({server.status})[/grey50]"
+
+        lines: list[RenderableType] = [Text.from_markup(server_text)]
+        for tool_name in server.tools:
+            lines.append(
+                BulletColumns(
+                    Text.from_markup(f"[grey50]{tool_name}[/grey50]"),
+                    bullet_style="grey50",
+                )
+            )
+        renderables.append(BulletColumns(Group(*lines), bullet_style=color))
+
+    return Group(*renderables)
+
+
+def render_mcp_prompt(snapshot: MCPStatusSnapshot, *, now: float | None = None) -> FormattedText:
+    if not snapshot.loading:
+        return FormattedText([])
+
+    fragments: list[tuple[str, str]] = []
+    colors = get_mcp_prompt_colors()
+    t = time.monotonic() if now is None else now
+    prefix = f"{'●' if int(t / 0.8) % 2 == 0 else ' '} "
+    fragments.append(
+        (
+            colors.text,
+            (
+                f"{prefix}MCP Servers: "
+                f"{snapshot.connected}/{snapshot.total} connected, {snapshot.tools} tools"
+            ),
+        )
+    )
+    fragments.append(("", "\n"))
+
+    for server in snapshot.servers:
+        fragments.append((_prompt_status_style(server.status), f"• {server.name}"))
+        detail = _prompt_server_detail(server)
+        if detail:
+            fragments.append((colors.detail, detail))
+        fragments.append(("", "\n"))
+
+    return FormattedText(fragments)
+
+
+def _status_color(status: str) -> str:
+    return {
+        "connected": "green",
+        "connecting": "cyan",
+        "pending": "yellow",
+        "failed": "red",
+        "unauthorized": "red",
+    }.get(status, "red")
+
+
+def _prompt_status_style(status: str) -> str:
+    colors = get_mcp_prompt_colors()
+    return {
+        "connected": colors.connected,
+        "connecting": colors.connecting,
+        "pending": colors.pending,
+        "failed": colors.failed,
+        "unauthorized": colors.failed,
+    }.get(status, colors.failed)
+
+
+def _prompt_server_detail(server: MCPServerSnapshot) -> str:
+    if server.status == "unauthorized":
+        return f" (unauthorized - run: pythinker mcp auth {server.name})"
+
+    parts: list[str] = []
+    if server.status != "connected":
+        parts.append(server.status)
+    if server.tools:
+        label = "tool" if len(server.tools) == 1 else "tools"
+        parts.append(f"{len(server.tools)} {label}")
+
+    return f" ({', '.join(parts)})" if parts else ""