pythinker-code 2.0.0__py3-none-any.whl

pythinker_code/ui/theme.py

@@ -0,0 +1,241 @@
+"""Centralized terminal color theme definitions.
+
+All UI-facing colors live here so that switching between dark and light
+terminal themes only requires changing the active ``ThemeName``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+from prompt_toolkit.styles import Style as PTKStyle
+from rich.style import Style as RichStyle
+
+type ThemeName = Literal["dark", "light"]
+
+
+# ---------------------------------------------------------------------------
+# Diff colors (used by utils/rich/diff_render.py)
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True, slots=True)
+class DiffColors:
+    add_bg: RichStyle
+    del_bg: RichStyle
+    add_hl: RichStyle
+    del_hl: RichStyle
+
+
+_DIFF_DARK = DiffColors(
+    add_bg=RichStyle(bgcolor="#12261e"),
+    del_bg=RichStyle(bgcolor="#2d1214"),
+    add_hl=RichStyle(bgcolor="#1a4a2e"),
+    del_hl=RichStyle(bgcolor="#5c1a1d"),
+)
+
+_DIFF_LIGHT = DiffColors(
+    add_bg=RichStyle(bgcolor="#dafbe1"),
+    del_bg=RichStyle(bgcolor="#ffebe9"),
+    add_hl=RichStyle(bgcolor="#aff5b4"),
+    del_hl=RichStyle(bgcolor="#ffc1c0"),
+)
+
+
+# ---------------------------------------------------------------------------
+# Task browser colors (used by ui/shell/task_browser.py)
+# ---------------------------------------------------------------------------
+
+
+def _task_browser_style_dark() -> PTKStyle:
+    return PTKStyle.from_dict(
+        {
+            "header": "bg:#1f2937 #e5e7eb",
+            "header.title": "bg:#1f2937 #67e8f9 bold",
+            "header.meta": "bg:#1f2937 #9ca3af",
+            "status.running": "bg:#1f2937 #86efac bold",
+            "status.success": "bg:#1f2937 #86efac",
+            "status.warning": "bg:#1f2937 #fbbf24",
+            "status.error": "bg:#1f2937 #fca5a5",
+            "status.info": "bg:#1f2937 #93c5fd",
+            "task-list": "bg:#111827 #d1d5db",
+            "task-list.checked": "bg:#164e63 #ecfeff bold",
+            "frame.border": "#155e75",
+            "frame.label": "bg:#0f172a #67e8f9 bold",
+            "footer": "bg:#0f172a #cbd5e1",
+            "footer.key": "bg:#0f172a #67e8f9 bold",
+            "footer.text": "bg:#0f172a #cbd5e1",
+            "footer.warning": "bg:#7f1d1d #fecaca bold",
+            "footer.meta": "bg:#0f172a #94a3b8",
+        }
+    )
+
+
+def _task_browser_style_light() -> PTKStyle:
+    return PTKStyle.from_dict(
+        {
+            "header": "bg:#e5e7eb #1f2937",
+            "header.title": "bg:#e5e7eb #0e7490 bold",
+            "header.meta": "bg:#e5e7eb #6b7280",
+            "status.running": "bg:#e5e7eb #166534 bold",
+            "status.success": "bg:#e5e7eb #166534",
+            "status.warning": "bg:#e5e7eb #92400e",
+            "status.error": "bg:#e5e7eb #991b1b",
+            "status.info": "bg:#e5e7eb #1e40af",
+            "task-list": "bg:#f9fafb #374151",
+            "task-list.checked": "bg:#cffafe #164e63 bold",
+            "frame.border": "#0e7490",
+            "frame.label": "bg:#f1f5f9 #0e7490 bold",
+            "footer": "bg:#f1f5f9 #475569",
+            "footer.key": "bg:#f1f5f9 #0e7490 bold",
+            "footer.text": "bg:#f1f5f9 #475569",
+            "footer.warning": "bg:#fee2e2 #991b1b bold",
+            "footer.meta": "bg:#f1f5f9 #64748b",
+        }
+    )
+
+
+# ---------------------------------------------------------------------------
+# Prompt / completion menu colors (used by ui/shell/prompt.py)
+# ---------------------------------------------------------------------------
+
+
+_PROMPT_STYLE_DARK = {
+    "bottom-toolbar": "noreverse",
+    "running-prompt-placeholder": "fg:#7c8594 italic",
+    "running-prompt-separator": "fg:#4a5568",
+    "slash-completion-menu": "",
+    "slash-completion-menu.separator": "fg:#4a5568",
+    "slash-completion-menu.marker": "fg:#4a5568",
+    "slash-completion-menu.marker.current": "fg:#4f9fff",
+    "slash-completion-menu.command": "fg:#a6adba",
+    "slash-completion-menu.meta": "fg:#7c8594",
+    "slash-completion-menu.command.current": "fg:#6fb7ff bold",
+    "slash-completion-menu.meta.current": "fg:#56a4ff",
+}
+
+_PROMPT_STYLE_LIGHT = {
+    "bottom-toolbar": "noreverse",
+    "running-prompt-placeholder": "fg:#6b7280 italic",
+    "running-prompt-separator": "fg:#d1d5db",
+    "slash-completion-menu": "",
+    "slash-completion-menu.separator": "fg:#d1d5db",
+    "slash-completion-menu.marker": "fg:#9ca3af",
+    "slash-completion-menu.marker.current": "fg:#2563eb",
+    "slash-completion-menu.command": "fg:#4b5563",
+    "slash-completion-menu.meta": "fg:#6b7280",
+    "slash-completion-menu.command.current": "fg:#1d4ed8 bold",
+    "slash-completion-menu.meta.current": "fg:#2563eb",
+}
+
+
+# ---------------------------------------------------------------------------
+# Bottom toolbar fragment colors (used by ui/shell/prompt.py)
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True, slots=True)
+class ToolbarColors:
+    separator: str
+    yolo_label: str
+    auto_label: str
+    plan_label: str
+    plan_prompt: str
+    cwd: str
+    bg_tasks: str
+    tip: str
+
+
+_TOOLBAR_DARK = ToolbarColors(
+    separator="fg:#4d4d4d",
+    yolo_label="bold fg:#ffff00",
+    auto_label="bold fg:#ff8800",
+    plan_label="bold fg:#00aaff",
+    plan_prompt="fg:#00aaff",
+    cwd="fg:#666666",
+    bg_tasks="fg:#888888",
+    tip="fg:#555555",
+)
+
+_TOOLBAR_LIGHT = ToolbarColors(
+    separator="fg:#d1d5db",
+    yolo_label="bold fg:#b45309",
+    auto_label="bold fg:#c2410c",
+    plan_label="bold fg:#2563eb",
+    plan_prompt="fg:#2563eb",
+    cwd="fg:#6b7280",
+    bg_tasks="fg:#4b5563",
+    tip="fg:#9ca3af",
+)
+
+
+# ---------------------------------------------------------------------------
+# MCP status prompt colors (used by ui/shell/mcp_status.py)
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True, slots=True)
+class MCPPromptColors:
+    text: str
+    detail: str
+    connected: str
+    connecting: str
+    pending: str
+    failed: str
+
+
+_MCP_PROMPT_DARK = MCPPromptColors(
+    text="fg:#d4d4d4",
+    detail="fg:#7c8594",
+    connected="fg:#56d364",
+    connecting="fg:#56a4ff",
+    pending="fg:#f2cc60",
+    failed="fg:#ff7b72",
+)
+
+_MCP_PROMPT_LIGHT = MCPPromptColors(
+    text="fg:#374151",
+    detail="fg:#6b7280",
+    connected="fg:#166534",
+    connecting="fg:#1d4ed8",
+    pending="fg:#92400e",
+    failed="fg:#dc2626",
+)
+
+
+# ---------------------------------------------------------------------------
+# Public API — resolve by theme name
+# ---------------------------------------------------------------------------
+
+_active_theme: ThemeName = "dark"
+
+
+def set_active_theme(theme: ThemeName) -> None:
+    global _active_theme
+    _active_theme = theme
+
+
+def get_active_theme() -> ThemeName:
+    return _active_theme
+
+
+def get_diff_colors() -> DiffColors:
+    return _DIFF_LIGHT if _active_theme == "light" else _DIFF_DARK
+
+
+def get_task_browser_style() -> PTKStyle:
+    return _task_browser_style_light() if _active_theme == "light" else _task_browser_style_dark()
+
+
+def get_prompt_style() -> PTKStyle:
+    d = _PROMPT_STYLE_LIGHT if _active_theme == "light" else _PROMPT_STYLE_DARK
+    return PTKStyle.from_dict(d)
+
+
+def get_toolbar_colors() -> ToolbarColors:
+    return _TOOLBAR_LIGHT if _active_theme == "light" else _TOOLBAR_DARK
+
+
+def get_mcp_prompt_colors() -> MCPPromptColors:
+    return _MCP_PROMPT_LIGHT if _active_theme == "light" else _MCP_PROMPT_DARK

pythinker_code/usage_ratelimit_cache.py

@@ -0,0 +1,175 @@
+"""Process-wide cache of rate-limit headers captured from chat completions.
+
+This is the universal fallback the `/usage` slash command renders for
+providers that don't have a dedicated usage adapter (e.g. MiniMax,
+OpenCode Go) or whose adapter returned no data. It's populated by an
+httpx event hook installed on the chat-completion HTTP client (see
+`pythinker_code.llm.create_llm`).
+
+The cache is intentionally process-wide and ephemeral — we only need the
+most recent snapshot per provider key and don't want disk persistence in
+v1.
+"""
+
+from __future__ import annotations
+
+import re
+import time
+from collections.abc import Mapping
+from dataclasses import dataclass
+from datetime import UTC, datetime
+
+
+@dataclass(slots=True, frozen=True)
+class RateLimitSnapshot:
+    """Most recent rate-limit state captured for one provider."""
+
+    requests_limit: int | None
+    requests_remaining: int | None
+    requests_reset_seconds: float | None  # seconds-from-now until reset
+    tokens_limit: int | None
+    tokens_remaining: int | None
+    tokens_reset_seconds: float | None
+    captured_at: float  # monotonic seconds when captured
+
+    @property
+    def has_any_data(self) -> bool:
+        return any(
+            v is not None
+            for v in (
+                self.requests_limit,
+                self.requests_remaining,
+                self.tokens_limit,
+                self.tokens_remaining,
+            )
+        )
+
+
+class RateLimitCache:
+    """In-memory map of `provider_key → most recent RateLimitSnapshot`."""
+
+    def __init__(self) -> None:
+        self._snapshots: dict[str, RateLimitSnapshot] = {}
+
+    def record(self, provider_key: str, headers: Mapping[str, str]) -> None:
+        snapshot = _parse_headers(headers)
+        if snapshot is not None and snapshot.has_any_data:
+            self._snapshots[provider_key] = snapshot
+
+    def snapshot(self, provider_key: str) -> RateLimitSnapshot | None:
+        return self._snapshots.get(provider_key)
+
+    def clear(self) -> None:
+        self._snapshots.clear()
+
+
+_CACHE = RateLimitCache()
+
+
+def get_cache() -> RateLimitCache:
+    """Return the process-wide rate-limit cache singleton."""
+    return _CACHE
+
+
+def _parse_headers(headers: Mapping[str, str]) -> RateLimitSnapshot | None:
+    """Try the known header schemas and return the first one that yields data."""
+    norm = {k.lower(): v for k, v in headers.items()}
+    return _parse_openai_shape(norm) or _parse_anthropic_shape(norm)
+
+
+def _parse_openai_shape(h: Mapping[str, str]) -> RateLimitSnapshot | None:
+    """OpenAI / OpenRouter / DeepSeek / Pythinker / OpenCode Go (openai-shape).
+
+    Headers: `x-ratelimit-{limit,remaining,reset}-{requests,tokens}`. Reset
+    values use the OpenAI duration format (e.g. `5s`, `1m30s`, `500ms`).
+    """
+    req_limit = _to_int(h.get("x-ratelimit-limit-requests"))
+    req_remaining = _to_int(h.get("x-ratelimit-remaining-requests"))
+    req_reset = _to_seconds(h.get("x-ratelimit-reset-requests"))
+    tok_limit = _to_int(h.get("x-ratelimit-limit-tokens"))
+    tok_remaining = _to_int(h.get("x-ratelimit-remaining-tokens"))
+    tok_reset = _to_seconds(h.get("x-ratelimit-reset-tokens"))
+    if req_limit is None and tok_limit is None:
+        return None
+    return RateLimitSnapshot(
+        requests_limit=req_limit,
+        requests_remaining=req_remaining,
+        requests_reset_seconds=req_reset,
+        tokens_limit=tok_limit,
+        tokens_remaining=tok_remaining,
+        tokens_reset_seconds=tok_reset,
+        captured_at=time.monotonic(),
+    )
+
+
+def _parse_anthropic_shape(h: Mapping[str, str]) -> RateLimitSnapshot | None:
+    """Anthropic uses `anthropic-ratelimit-{requests,tokens}-{limit,remaining,reset}`.
+
+    Reset values are ISO-8601 timestamps, not durations.
+    """
+    req_limit = _to_int(h.get("anthropic-ratelimit-requests-limit"))
+    req_remaining = _to_int(h.get("anthropic-ratelimit-requests-remaining"))
+    req_reset_iso = h.get("anthropic-ratelimit-requests-reset")
+    tok_limit = _to_int(h.get("anthropic-ratelimit-tokens-limit"))
+    tok_remaining = _to_int(h.get("anthropic-ratelimit-tokens-remaining"))
+    tok_reset_iso = h.get("anthropic-ratelimit-tokens-reset")
+    if req_limit is None and tok_limit is None:
+        return None
+    return RateLimitSnapshot(
+        requests_limit=req_limit,
+        requests_remaining=req_remaining,
+        requests_reset_seconds=_iso_to_seconds(req_reset_iso),
+        tokens_limit=tok_limit,
+        tokens_remaining=tok_remaining,
+        tokens_reset_seconds=_iso_to_seconds(tok_reset_iso),
+        captured_at=time.monotonic(),
+    )
+
+
+def _to_int(value: str | None) -> int | None:
+    if value is None:
+        return None
+    try:
+        return int(float(value))
+    except (TypeError, ValueError):
+        return None
+
+
+_DURATION_RE = re.compile(r"(\d+(?:\.\d+)?)\s*(ms|s|m|h)")
+
+
+def _to_seconds(value: str | None) -> float | None:
+    """Parse OpenAI's reset-duration format. Examples: `5s`, `1m30s`, `500ms`."""
+    if value is None:
+        return None
+    text = value.strip().lower()
+    if not text:
+        return None
+    try:
+        return float(text)
+    except ValueError:
+        pass
+    total = 0.0
+    for amount, unit in _DURATION_RE.findall(text):
+        n = float(amount)
+        if unit == "ms":
+            total += n / 1000
+        elif unit == "s":
+            total += n
+        elif unit == "m":
+            total += n * 60
+        elif unit == "h":
+            total += n * 3600
+    return total if total > 0 else None
+
+
+def _iso_to_seconds(value: str | None) -> float | None:
+    """Convert an ISO-8601 timestamp into seconds-from-now (clamped at 0)."""
+    if value is None:
+        return None
+    try:
+        dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except (TypeError, ValueError):
+        return None
+    delta = (dt - datetime.now(UTC)).total_seconds()
+    return delta if delta > 0 else 0.0

pythinker_code/utils/aiohttp.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import ssl
+
+import aiohttp
+import certifi
+
+_ssl_context = ssl.create_default_context(cafile=certifi.where())
+
+_DEFAULT_TIMEOUT = aiohttp.ClientTimeout(
+    total=120,
+    sock_read=60,
+    sock_connect=15,
+)
+
+
+def new_client_session(
+    *,
+    timeout: aiohttp.ClientTimeout | None = None,
+) -> aiohttp.ClientSession:
+    return aiohttp.ClientSession(
+        connector=aiohttp.TCPConnector(ssl=_ssl_context),
+        timeout=timeout or _DEFAULT_TIMEOUT,
+    )

pythinker_code/utils/aioqueue.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+
+if sys.version_info >= (3, 13):
+    QueueShutDown = asyncio.QueueShutDown  # type: ignore[assignment]
+
+    class Queue[T](asyncio.Queue[T]):
+        """Asyncio Queue with shutdown support."""
+
+else:
+
+    class QueueShutDown(Exception):
+        """Raised when operating on a shut down queue."""
+
+    class _Shutdown:
+        """Sentinel for queue shutdown."""
+
+    _SHUTDOWN = _Shutdown()
+
+    class Queue[T](asyncio.Queue[T | _Shutdown]):
+        """Asyncio Queue with shutdown support for Python < 3.13."""
+
+        def __init__(self) -> None:
+            super().__init__()
+            self._shutdown = False
+
+        def shutdown(self, immediate: bool = False) -> None:
+            if self._shutdown:
+                return
+            self._shutdown = True
+            if immediate:
+                self._queue.clear()
+
+            getters = list(getattr(self, "_getters", []))
+            count = max(1, len(getters))
+            self._enqueue_shutdown(count)
+
+        def _enqueue_shutdown(self, count: int) -> None:
+            for _ in range(count):
+                try:
+                    super().put_nowait(_SHUTDOWN)
+                except asyncio.QueueFull:
+                    self._queue.clear()
+                    super().put_nowait(_SHUTDOWN)
+
+        async def get(self) -> T:
+            if self._shutdown and self.empty():
+                raise QueueShutDown
+            item = await super().get()
+            if isinstance(item, _Shutdown):
+                raise QueueShutDown
+            return item
+
+        def get_nowait(self) -> T:
+            if self._shutdown and self.empty():
+                raise QueueShutDown
+            item = super().get_nowait()
+            if isinstance(item, _Shutdown):
+                raise QueueShutDown
+            return item
+
+        async def put(self, item: T) -> None:
+            if self._shutdown:
+                raise QueueShutDown
+            await super().put(item)
+
+        def put_nowait(self, item: T) -> None:
+            if self._shutdown:
+                raise QueueShutDown
+            super().put_nowait(item)

pythinker_code/utils/broadcast.py

@@ -0,0 +1,37 @@
+import asyncio
+
+from pythinker_code.utils.aioqueue import Queue
+
+
+class BroadcastQueue[T]:
+    """
+    A broadcast queue that allows multiple subscribers to receive published items.
+    """
+
+    def __init__(self) -> None:
+        self._queues: set[Queue[T]] = set()
+
+    def subscribe(self) -> Queue[T]:
+        """Create a new subscription queue."""
+        queue: Queue[T] = Queue()
+        self._queues.add(queue)
+        return queue
+
+    def unsubscribe(self, queue: Queue[T]) -> None:
+        """Remove a subscription queue."""
+        self._queues.discard(queue)
+
+    async def publish(self, item: T) -> None:
+        """Publish an item to all subscription queues."""
+        await asyncio.gather(*(queue.put(item) for queue in self._queues))
+
+    def publish_nowait(self, item: T) -> None:
+        """Publish an item to all subscription queues without waiting."""
+        for queue in self._queues:
+            queue.put_nowait(item)
+
+    def shutdown(self, immediate: bool = False) -> None:
+        """Close all subscription queues."""
+        for queue in self._queues:
+            queue.shutdown(immediate=immediate)
+        self._queues.clear()

pythinker_code/utils/changelog.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import NamedTuple
+
+
+class ReleaseEntry(NamedTuple):
+    description: str
+    entries: list[str]
+
+
+def parse_changelog(md_text: str) -> dict[str, ReleaseEntry]:
+    """Parse a subset of Keep a Changelog-style markdown into a map:
+    version -> (description, entries)
+
+    Parsing rules:
+    - Versions are denoted by level-2 headings starting with '## ['
+      Example: `## [v0.10.1] - 2025-09-18` or `## [Unreleased]`
+    - For each version section, description is the first contiguous block of
+      non-empty lines that do not start with '-' or '#'.
+    - Entries are all markdown list items starting with '- ' under that version
+      (across any subheadings like '### Added').
+    """
+    lines = md_text.splitlines()
+    result: dict[str, ReleaseEntry] = {}
+
+    current_ver: str | None = None
+    collecting_desc = False
+    desc_lines: list[str] = []
+    bullet_lines: list[str] = []
+    seen_content_after_header = False
+
+    def commit():
+        nonlocal current_ver, desc_lines, bullet_lines, result
+        if current_ver is None:
+            return
+        description = "\n".join([line.strip() for line in desc_lines]).strip()
+        # Deduplicate and normalize entries
+        norm_entries = [
+            line.strip()[2:].strip() for line in bullet_lines if line.strip().startswith("- ")
+        ]
+        result[current_ver] = ReleaseEntry(description=description, entries=norm_entries)
+
+    for raw in lines:
+        line = raw.rstrip()
+        # Format: `## 0.75 (2026-01-09)` or `## Unreleased`
+        if line.startswith("## "):
+            commit()
+            ver = line[3:].strip()
+            # Remove trailing date in parentheses if present
+            if "(" in ver:
+                ver = ver[: ver.find("(")].strip()
+            current_ver = ver
+            desc_lines = []
+            bullet_lines = []
+            collecting_desc = True
+            seen_content_after_header = False
+            continue
+
+        if current_ver is None:
+            # Skip until first version section
+            continue
+
+        if not line.strip():
+            # blank line ends initial description block only after we've seen content
+            if collecting_desc and seen_content_after_header:
+                collecting_desc = False
+            continue
+
+        seen_content_after_header = True
+
+        if line.lstrip().startswith("### "):
+            collecting_desc = False
+            continue
+
+        if line.lstrip().startswith("- "):
+            collecting_desc = False
+            bullet_lines.append(line.strip())
+            continue
+
+        if collecting_desc:
+            # Accumulate description until a blank line or bullets/subheadings
+            desc_lines.append(line.strip())
+        # else: ignore any other free-form text after description block
+
+    # Final flush
+    commit()
+    return result
+
+
+def format_release_notes(changelog: dict[str, ReleaseEntry], include_lib_changes: bool) -> str:
+    parts: list[str] = []
+    for ver, entry in changelog.items():
+        s = f"[bold]{ver}[/bold]"
+        if entry.description:
+            s += f": {entry.description}"
+        if entry.entries:
+            for it in entry.entries:
+                if it.lower().startswith("lib:") and not include_lib_changes:
+                    continue
+                s += "\n[markdown.item.bullet]• [/]" + it
+        parts.append(s + "\n")
+    return "\n".join(parts).strip()
+
+
+CHANGELOG = parse_changelog(
+    (Path(__file__).parent.parent / "CHANGELOG.md").read_text(encoding="utf-8")
+)