tau-coding-agent 0.1.0__py3-none-any.whl

tau/tui/utils.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+def project_name() -> str:
+    """Best-effort project name: git repo root dir name, else cwd dir name."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            timeout=1,
+        )
+        if result.returncode == 0:
+            return Path(result.stdout.strip()).name
+    except (OSError, subprocess.SubprocessError):
+        pass
+    return Path.cwd().name

tau/utils/http_proxy.py

@@ -0,0 +1,221 @@
+"""HTTP proxy resolution from settings or environment variables.
+
+Supports proxy configuration from:
+1. settings.json (http_proxy.http_proxy, http_proxy.https_proxy, http_proxy.no_proxy)
+2. Environment variables: HTTP_PROXY, HTTPS_PROXY, ALL_PROXY, NO_PROXY (and lowercase variants)
+3. npm config variants: npm_config_http_proxy, npm_config_https_proxy, etc.
+
+Settings.json takes precedence over environment variables.
+
+Example:
+    from tau.utils.http_proxy import get_proxy_url_for_target
+
+    proxy_url = get_proxy_url_for_target("https://api.anthropic.com")
+    if proxy_url:
+        print(f"Using proxy: {proxy_url}")
+"""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Optional
+from urllib.parse import urlparse
+
+if TYPE_CHECKING:
+    from tau.settings.manager import SettingsManager
+
+UNSUPPORTED_PROXY_PROTOCOL_MESSAGE = (
+    "Unsupported proxy protocol. SOCKS and PAC proxy URLs are not supported; "
+    "use an HTTP or HTTPS proxy URL."
+)
+
+DEFAULT_PROXY_PORTS = {
+    "ftp": 21,
+    "gopher": 70,
+    "http": 80,
+    "https": 443,
+    "ws": 80,
+    "wss": 443,
+}
+
+
+def _get_proxy_env(key: str) -> str:
+    """Get proxy environment variable (case-insensitive)."""
+    return os.environ.get(key.lower(), "") or os.environ.get(key.upper(), "")
+
+
+def _parse_proxy_target_url(target_url: str) -> Optional[tuple[str, str, int]]:
+    """Parse target URL into (scheme, hostname, port) or None if invalid."""
+    try:
+        parsed = urlparse(target_url)
+        if not parsed.scheme or not parsed.hostname:
+            return None
+        scheme = parsed.scheme
+        hostname = parsed.hostname
+        port = parsed.port or DEFAULT_PROXY_PORTS.get(scheme, 0)
+        return (scheme, hostname, port)
+    except Exception:
+        return None
+
+
+def _should_proxy_hostname(hostname: str, port: int, no_proxy: Optional[str] = None) -> bool:
+    """Check if hostname should be proxied (respecting NO_PROXY).
+
+    Args:
+        hostname: Hostname to check
+        port: Port number
+        no_proxy: Optional NO_PROXY string. If not provided, checks environment variables.
+    """
+    if no_proxy is None:
+        no_proxy = _get_proxy_env("no_proxy").lower()
+    else:
+        no_proxy = no_proxy.lower()
+
+    if not no_proxy:
+        return True
+    if no_proxy == "*":
+        return False
+
+    # NO_PROXY is comma or space-separated list of hosts/patterns to exclude
+    for entry in no_proxy.split(","):
+        entry = entry.strip()
+        if not entry:
+            continue
+
+        # Parse host:port format
+        if ":" in entry:
+            proxy_host, proxy_port_str = entry.rsplit(":", 1)
+            try:
+                proxy_port = int(proxy_port_str)
+                if proxy_port != port:
+                    continue  # Port mismatch, check next entry
+            except ValueError:
+                proxy_host = entry
+                proxy_port = None
+        else:
+            proxy_host = entry
+            proxy_port = None
+
+        # Match hostname (supports wildcards like *.example.com)
+        if proxy_host.startswith("*."):
+            # Wildcard match: *.example.com matches sub.example.com
+            if hostname.endswith(proxy_host[1:]):  # Remove leading * and keep .
+                return False
+        elif proxy_host == hostname:
+            return False
+
+    return True
+
+
+def get_proxy_url_for_target(target_url: str, settings_manager: Optional[SettingsManager] = None) -> Optional[str]:
+    """
+    Get HTTP proxy URL for a target URL from settings or environment variables.
+
+    Checks in order:
+    1. Settings (from settings.json http_proxy.url) - takes precedence
+    2. Environment variables (HTTP_PROXY, HTTPS_PROXY, ALL_PROXY, etc.)
+
+    Args:
+        target_url: Target URL to find proxy for (e.g., "https://api.anthropic.com")
+        settings_manager: Optional SettingsManager to check for http_proxy settings
+
+    Returns:
+        Proxy URL (e.g., "http://proxy.example.com:8080") or None if no proxy
+
+    Raises:
+        ValueError: If proxy URL uses unsupported protocol (SOCKS, PAC)
+    """
+    parsed = _parse_proxy_target_url(target_url)
+    if not parsed:
+        return None
+
+    protocol, hostname, port = parsed
+
+    # Check settings first (takes precedence over env vars)
+    if settings_manager:
+        settings_proxy = settings_manager.get_proxy_url()
+        if settings_proxy:
+            # Check NO_PROXY exclusions from settings
+            no_proxy = settings_manager.get_no_proxy()
+            if not _should_proxy_hostname(hostname, port, no_proxy):
+                return None
+            _validate_proxy_url(settings_proxy)
+            return settings_proxy
+
+    # Fall back to environment variables
+    if not _should_proxy_hostname(hostname, port):
+        return None
+
+    proxy = _get_proxy_env(f"{protocol}_proxy") or _get_proxy_env("all_proxy")
+    if not proxy:
+        return None
+
+    if "://" not in proxy:
+        # Add scheme if missing
+        proxy = f"{protocol}://{proxy}"
+
+    _validate_proxy_url(proxy)
+    return proxy
+
+
+def _validate_proxy_url(proxy: str) -> None:
+    """Validate proxy URL format and protocol."""
+    try:
+        parsed = urlparse(proxy)
+    except Exception as e:
+        raise ValueError(f"Invalid proxy URL {proxy!r}: {e}")
+
+    if parsed.scheme not in ("http", "https"):
+        raise ValueError(f"{UNSUPPORTED_PROXY_PROTOCOL_MESSAGE} Got {parsed.scheme!r}")
+
+
+def get_proxies_for_client(
+    api_base_url: str, settings_manager: Optional[SettingsManager] = None
+) -> Optional[dict[str, str]]:
+    """
+    Get proxy configuration dict for httpx.AsyncClient or requests.
+
+    Returns a dict suitable for httpx:
+        async with httpx.AsyncClient(proxies=proxies) as client:
+            ...
+
+    Args:
+        api_base_url: Base URL of the API (e.g., "https://api.anthropic.com")
+        settings_manager: Optional SettingsManager to check for http_proxy settings
+
+    Returns:
+        {"http://": proxy_url, "https://": proxy_url} or None if no proxy needed
+
+    Raises:
+        ValueError: If proxy URL uses unsupported protocol
+    """
+    proxy_url = get_proxy_url_for_target(api_base_url, settings_manager)
+    if not proxy_url:
+        return None
+
+    # httpx expects separate keys for http and https
+    return {
+        "http://": proxy_url,
+        "https://": proxy_url,
+    }
+
+
+def get_proxy_headers(settings_manager: Optional[SettingsManager] = None) -> Optional[dict[str, str]]:
+    """
+    Get custom proxy headers for proxy authentication.
+
+    Some corporate proxies require custom headers for authentication (e.g., "Proxy-Authorization").
+
+    Args:
+        settings_manager: Optional SettingsManager to check for custom proxy headers
+
+    Returns:
+        Dict of custom headers to send to proxy, or None if none configured
+
+    Example:
+        headers = get_proxy_headers(settings_manager)
+        proxy_headers = {**(headers or {}), "X-Custom-Auth": "token"}
+    """
+    if not settings_manager:
+        return None
+    return settings_manager.get_proxy_headers()

tau/utils/image_processing.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import io
+from dataclasses import dataclass
+
+# Provider limits — 4.5 MB gives headroom below Anthropic's 5 MB hard limit
+_DEFAULT_MAX_WIDTH = 2000
+_DEFAULT_MAX_HEIGHT = 2000
+_DEFAULT_MAX_BYTES = int(4.5 * 1024 * 1024)
+
+_DEFAULT_JPEG_QUALITY = 80
+_JPEG_QUALITY_STEPS = [80, 85, 70, 55, 40]
+_SCALE_STEP = 0.75
+
+
+@dataclass
+class ProcessedImage:
+    data: bytes
+    mime_type: str
+    original_width: int
+    original_height: int
+    display_width: int
+    display_height: int
+
+    @property
+    def was_resized(self) -> bool:
+        return (self.display_width, self.display_height) != (self.original_width, self.original_height)
+
+    def dimension_note(self) -> str | None:
+        """Coordinate-mapping hint for the LLM when the image was scaled down."""
+        if not self.was_resized:
+            return None
+        scale_x = self.original_width / max(1, self.display_width)
+        scale_y = self.original_height / max(1, self.display_height)
+        scale = round((scale_x + scale_y) / 2, 2)
+        return (
+            f"[Image: original {self.original_width}x{self.original_height}, "
+            f"displayed at {self.display_width}x{self.display_height}. "
+            f"Multiply coordinates by {scale} to map to original image.]"
+        )
+
+
+def process_image(
+    data: bytes,
+    max_width: int = _DEFAULT_MAX_WIDTH,
+    max_height: int = _DEFAULT_MAX_HEIGHT,
+    max_bytes: int = _DEFAULT_MAX_BYTES,
+    auto_resize: bool = True,
+    to_png: bool = False,
+    jpeg_quality: int = _DEFAULT_JPEG_QUALITY,
+) -> ProcessedImage:
+    """
+    Full image processing pipeline:
+      1. EXIF orientation correction
+      2. Resize to fit max_width × max_height (if auto_resize)
+      3. Try both PNG and JPEG, pick whichever is smaller and fits max_bytes;
+         if still too large, reduce JPEG quality then scale dimensions down
+      4. Optionally force PNG output (required for Kitty graphics protocol)
+
+    Returns a ProcessedImage with the processed bytes and dimension metadata.
+    """
+    from PIL import Image, ImageOps
+
+    img = Image.open(io.BytesIO(data))
+
+    # 1. EXIF orientation — one call handles all 8 rotations
+    img = ImageOps.exif_transpose(img)
+
+    original_width, original_height = img.size
+
+    # 2. Resize to fit provider limits
+    if auto_resize:
+        img = _resize_to_fit(img, max_width, max_height)
+
+    display_width, display_height = img.size
+
+    # 3. Encode, picking the best format within the byte budget
+    encoded, mime_type = _encode_best(img, max_bytes, jpeg_quality, force_png=to_png)
+
+    return ProcessedImage(
+        data=encoded,
+        mime_type=mime_type,
+        original_width=original_width,
+        original_height=original_height,
+        display_width=display_width,
+        display_height=display_height,
+    )
+
+
+def convert_to_png(data: bytes) -> bytes:
+    """Convert any supported image format to PNG bytes (for Kitty protocol)."""
+    from PIL import Image, ImageOps
+    img = ImageOps.exif_transpose(Image.open(io.BytesIO(data)))
+    return _encode_png(img)
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _resize_to_fit(img: "Image.Image", max_w: int, max_h: int) -> "Image.Image":
+    from PIL import Image
+    w, h = img.size
+    if w <= max_w and h <= max_h:
+        return img
+    scale = min(max_w / w, max_h / h)
+    return img.resize((max(1, int(w * scale)), max(1, int(h * scale))), Image.LANCZOS)
+
+
+def _as_rgb(img: "Image.Image") -> "Image.Image":
+    if img.mode not in ("RGB", "L"):
+        return img.convert("RGB")
+    return img
+
+
+def _encode_png(img: "Image.Image") -> bytes:
+    from PIL import Image
+    if img.mode not in ("RGB", "RGBA", "L", "LA", "P"):
+        img = img.convert("RGBA")
+    buf = io.BytesIO()
+    img.save(buf, format="PNG", optimize=True)
+    return buf.getvalue()
+
+
+def _encode_jpeg(img: "Image.Image", quality: int) -> bytes:
+    buf = io.BytesIO()
+    _as_rgb(img).save(buf, format="JPEG", quality=quality)
+    return buf.getvalue()
+
+
+def _encode_best(
+    img: "Image.Image",
+    max_bytes: int,
+    jpeg_quality: int,
+    force_png: bool,
+) -> tuple[bytes, str]:
+    """
+    Try PNG and JPEG at each candidate size and pick whichever is smaller
+    and fits within max_bytes.  Mirrors tryEncodings strategy.
+    """
+    from PIL import Image
+
+    qualities = list(dict.fromkeys([jpeg_quality] + _JPEG_QUALITY_STEPS))
+
+    current = img
+    while True:
+        png = _encode_png(current)
+        jpegs = [_encode_jpeg(current, q) for q in qualities]
+
+        # Collect all candidates that fit, pick the smallest
+        candidates: list[tuple[bytes, str]] = []
+        if not force_png:
+            for j in jpegs:
+                if len(j) <= max_bytes:
+                    candidates.append((j, "image/jpeg"))
+        if len(png) <= max_bytes:
+            candidates.append((png, "image/png"))
+
+        if candidates:
+            best = min(candidates, key=lambda c: len(c[0]))
+            return best
+
+        # Nothing fit — scale down and retry
+        w, h = current.size
+        if w <= 1 and h <= 1:
+            break
+        nw = max(1, int(w * _SCALE_STEP))
+        nh = max(1, int(h * _SCALE_STEP))
+        if nw == w and nh == h:
+            break
+        current = img.resize((nw, nh), Image.LANCZOS)
+
+    # Last resort: return whatever PNG we have
+    return _encode_png(img), "image/png"

tau/utils/secrets.py

@@ -0,0 +1,59 @@
+"""Resolve secret references (API keys, tokens, proxy creds) to their values.
+
+A "secret reference" is a string that may be one of three forms:
+
+  - ``"literal-value"``  → returned unchanged
+  - ``"$ENV_VAR"``       → read from ``os.environ`` (empty string if unset)
+  - ``"!shell command"`` → run in a shell; its trimmed stdout is the value
+
+Resolution is **memoized**: a ``$VAR`` / ``!command`` reference is read/executed
+only the first time it is seen, and the resolved value is kept in memory for the
+life of the process. Subsequent lookups return the cached value, so callers on a
+hot path (per-request headers, proxy config) never re-run the command.
+
+Failed resolutions (empty result) are *not* cached, so fixing the environment or
+the command and reloading re-resolves rather than being stuck on the empty value.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+
+_cache: dict[str, str] = {}
+
+
+def resolve_secret(value: str | None) -> str:
+    """Resolve a single secret reference to its value (memoized). See module docs."""
+    if not value:
+        return ""
+    cached = _cache.get(value)
+    if cached is not None:
+        return cached
+
+    if value.startswith("$"):
+        resolved = os.environ.get(value[1:], "")
+    elif value.startswith("!"):
+        resolved = subprocess.run(
+            value[1:], shell=True, capture_output=True, text=True
+        ).stdout.strip()
+    else:
+        resolved = value
+
+    if resolved:  # don't cache failures — allow a later retry after a fix
+        _cache[value] = resolved
+    return resolved
+
+
+def resolve_secrets(values: dict[str, str] | None) -> dict[str, str]:
+    """Resolve every string value in a mapping (e.g. a header dict)."""
+    if not values:
+        return {}
+    return {
+        k: resolve_secret(v) if isinstance(v, str) else v
+        for k, v in values.items()
+    }
+
+
+def clear_cache() -> None:
+    """Forget all memoized resolutions (e.g. for tests or a hard reload)."""
+    _cache.clear()

tau/utils/version_check.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+_TIMEOUT = 5.0
+
+
+def _pypi_url() -> str:
+    """PyPI JSON endpoint for this app's distribution (keyed on the app name)."""
+    from tau.settings.paths import get_package_name
+
+    return f"https://pypi.org/pypi/{get_package_name()}/json"
+
+
+def _is_newer(latest: str, current: str) -> bool:
+    """True if ``latest`` is a strictly newer release than ``current``.
+
+    Uses PEP 440 comparison (handles rc/dev/post suffixes correctly). Falls back
+    to a naive dotted-int compare if packaging is unavailable or a version string
+    is non-standard; on total failure, conservatively reports "not newer".
+    """
+    try:
+        from packaging.version import InvalidVersion, Version
+
+        try:
+            return Version(latest) > Version(current)
+        except InvalidVersion:
+            pass
+    except ImportError:
+        pass
+
+    def _parse(v: str) -> tuple[int, ...]:
+        parts = []
+        for x in v.strip().split("."):
+            try:
+                parts.append(int(x))
+            except ValueError:
+                pass
+        return tuple(parts)
+
+    try:
+        return _parse(latest) > _parse(current)
+    except Exception:
+        return False
+
+
+async def check_for_new_version(current_version: str) -> str | None:
+    """Return the latest PyPI version string if newer than current, else None."""
+    try:
+        import httpx
+
+        async with httpx.AsyncClient(timeout=_TIMEOUT) as client:
+            resp = await client.get(_pypi_url(), headers={"Accept": "application/json"})
+            if not resp.is_success:
+                return None
+            data = resp.json()
+            latest = data.get("info", {}).get("version", "")
+            if latest and _is_newer(latest, current_version):
+                return latest
+    except Exception:
+        return None
+    return None