pythinker-code 0.8.0__py3-none-any.whl

pythinker_code/ui/tui_config.py

@@ -0,0 +1,82 @@
+"""Resolve the active TUI style from env var or loaded config.
+
+Single accessor used by call sites to decide between the legacy
+``pythinker`` worklog rendering path and the ``card`` style. Keeps the
+flag-resolution logic in one place so the migration's escape hatch can be
+removed cleanly once the card style stabilizes.
+
+Card style is the default; set ``PYTHINKER_TUI_STYLE=pythinker`` or
+``tui.style = "pythinker"`` to use legacy rendering.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Literal
+
+TUIStyle = Literal["pythinker", "card"]
+
+_ENV_VAR = "PYTHINKER_TUI_STYLE"
+_VALID: frozenset[str] = frozenset(("pythinker", "card"))
+
+_active_tui_style: TUIStyle = "card"
+"""Process-level active style. Set at shell startup from ``Config.tui.style``;
+used as the fallback when neither env var nor a per-call ``configured`` value
+is provided."""
+
+
+def _normalize(value: str | None) -> TUIStyle | None:
+    if value is None:
+        return None
+    cleaned = value.strip().lower()
+    if cleaned in _VALID:
+        return cleaned  # type: ignore[return-value]
+    return None
+
+
+def _from_env() -> TUIStyle | None:
+    """Read the env var override. Returns None when unset or invalid."""
+    return _normalize(os.environ.get(_ENV_VAR))
+
+
+def set_active_tui_style(style: TUIStyle | str | None) -> None:
+    """Set the process-level active style.
+
+    Called once at shell startup from the loaded config. Invalid or None
+    values fall back to ``"card"`` so a stale config can't break the shell.
+    """
+    global _active_tui_style
+    normalized = _normalize(style if isinstance(style, str) else None)
+    _active_tui_style = normalized if normalized is not None else "card"
+
+
+def get_active_tui_style() -> TUIStyle:
+    """Return the process-level active style (without env override)."""
+    return _active_tui_style
+
+
+def get_tui_style(configured: TUIStyle | str | None = None) -> TUIStyle:
+    """Return the effective TUI style.
+
+    Resolution order (first match wins):
+      1. ``PYTHINKER_TUI_STYLE`` env var, if set to a valid value
+      2. *configured* argument (when provided and valid)
+      3. Process-level active style set via :func:`set_active_tui_style`
+      4. ``"card"`` (initial default)
+
+    Unrecognized values fall through to the next layer rather than raising,
+    so a stale env var or older config can't break the shell.
+    """
+    env = _from_env()
+    if env is not None:
+        return env
+    if isinstance(configured, str):
+        normalized = _normalize(configured)
+        if normalized is not None:
+            return normalized
+    return _active_tui_style
+
+
+def is_card_style(configured: TUIStyle | str | None = None) -> bool:
+    """Convenience predicate for ``get_tui_style(...) == "card"``."""
+    return get_tui_style(configured) == "card"

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,38 @@
+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."""
+        queues = list(self._queues)
+        await asyncio.gather(*(queue.put(item) for queue in queues))
+
+    def publish_nowait(self, item: T) -> None:
+        """Publish an item to all subscription queues without waiting."""
+        for queue in list(self._queues):
+            queue.put_nowait(item)
+
+    def shutdown(self, immediate: bool = False) -> None:
+        """Close all subscription queues."""
+        for queue in list(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")
+)