code-puppy 0.0.641__tar.gz → 0.0.643__tar.gz

{code_puppy-0.0.641 → code_puppy-0.0.643}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.641
+Version: 0.0.643
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.641 → code_puppy-0.0.643}/code_puppy/agents/_runtime.py

@@ -987,7 +987,14 @@ async def _run_with_mcp_impl(
     run_success = False
     run_error: Optional[BaseException] = None
     run_response_text = ""
-    run_usage_output_tokens: Optional[int] = None
+    run_usage_metadata: dict[str, int | None] = {
+        "usage_input_tokens": None,
+        "usage_output_tokens": None,
+        "usage_total_tokens": None,
+        "usage_cached_read_tokens": None,
+        "usage_cached_write_tokens": None,
+        "usage_thought_tokens": None,
+    }
 
     try:
         # Nested runs (e.g. shell_safety mid-run) leave the SIGINT handler
@@ -1044,13 +1051,37 @@ async def _run_with_mcp_impl(
         run_success = True
         run_response_text = _extract_response_text(result)
         try:
-            # Real billed output tokens -- calibrates the run-stats TG
-            # estimate (see run_stats.snapshot_cycle_into_aggregates).
-            run_usage_output_tokens = (
-                int(getattr(result.usage(), "output_tokens", 0) or 0) or None
-            )
+            usage = result.usage()
+
+            def _pick_usage_int(*names: str) -> int | None:
+                for name in names:
+                    value = getattr(usage, name, None)
+                    if value is not None:
+                        return int(value) or None
+                return None
+
+            run_usage_metadata = {
+                "usage_input_tokens": _pick_usage_int(
+                    "input_tokens", "request_tokens", "prompt_tokens"
+                ),
+                # Real billed output tokens -- calibrates the run-stats TG
+                # estimate (see run_stats.snapshot_cycle_into_aggregates).
+                "usage_output_tokens": _pick_usage_int(
+                    "output_tokens", "response_tokens", "completion_tokens"
+                ),
+                "usage_total_tokens": _pick_usage_int("total_tokens"),
+                "usage_cached_read_tokens": _pick_usage_int(
+                    "cache_read_tokens", "cached_read_tokens"
+                ),
+                "usage_cached_write_tokens": _pick_usage_int(
+                    "cache_write_tokens", "cached_write_tokens"
+                ),
+                "usage_thought_tokens": _pick_usage_int(
+                    "thinking_tokens", "thought_tokens", "reasoning_tokens"
+                ),
+            }
         except Exception:
-            run_usage_output_tokens = None
+            pass
         return result
     except asyncio.CancelledError:
         run_response_text = ""
@@ -1086,7 +1117,7 @@ async def _run_with_mcp_impl(
                 response_text=run_response_text,
                 metadata={
                     "model": agent.get_model_name(),
-                    "usage_output_tokens": run_usage_output_tokens,
+                    **run_usage_metadata,
                 },
             )
         except Exception:

{code_puppy-0.0.641 → code_puppy-0.0.643}/code_puppy/config.py

@@ -325,6 +325,23 @@ def get_owner_name():
     return get_value("owner_name") or "Master"
 
 
+def get_locale() -> str:
+    """Return the active i18n locale (single source of truth).
+
+    Delegates to the i18n translator, seeding it once from the environment
+    and the persisted ``locale`` config key on first use. After a runtime
+    ``/set locale`` (translator.set_locale), this reflects that override
+    rather than re-deriving from the environment.
+
+    Precedence when seeding: CODE_PUPPY_LOCALE env var > persisted ``locale``
+    config key > POSIX locale env vars > default (en-US). See
+    ``code_puppy.i18n.locale.detect_locale``.
+    """
+    from code_puppy.i18n import ensure_detected
+
+    return ensure_detected(get_value("locale"))
+
+
 # Legacy function removed - message history limit is no longer used
 # Message history is now managed by token-based compaction system
 # using get_protected_token_count() and get_summarization_threshold()
@@ -388,6 +405,7 @@ def get_config_keys():
         "frontend_emitter_enabled",
         "frontend_emitter_max_recent_events",
         "frontend_emitter_queue_size",
+        "locale",
     ]
     # 'enable_dbos' is reserved for the dbos_durable_exec plugin and is read
     # via the generic get_value API; intentionally not in default_keys.

code_puppy-0.0.643/code_puppy/i18n/__init__.py

@@ -0,0 +1,79 @@
+"""Code Puppy internationalization (i18n) foundation.
+
+Day-one localization framework: message catalogs with a fallback chain,
+locale detection/override, plural-aware translation, locale-aware formatting,
+and pseudolocalization for coverage testing. Stdlib-only by design.
+
+Typical call-site usage::
+
+    from code_puppy.i18n import t, ngettext
+
+    emit_info(t("startup.welcome", name=owner))
+    emit_info(ngettext("files.deleted", count=n))
+
+To resolve the active locale from the environment/config at boot::
+
+    from code_puppy.i18n import use_detected_locale
+    from code_puppy.config import get_value
+
+    use_detected_locale(get_value("locale"))
+
+See ``PUP-473`` (epic) and ``PUP-475`` (this foundation story) for scope.
+"""
+
+from .catalog import add_catalog_dir, available_locales, load_catalog, lookup, reset
+from .formats import format_datetime, format_number
+from .locale import (
+    DEFAULT_LOCALE,
+    detect_locale,
+    fallback_chain,
+    language_of,
+    normalize_locale,
+)
+from .plurals import plural_category
+from .pseudo import PSEUDO_LOCALE, is_pseudo_locale, pseudolocalize
+from .translate import (
+    LazyTranslation,
+    Translator,
+    ensure_detected,
+    get_locale,
+    get_translator,
+    lazy,
+    ngettext,
+    set_locale,
+    t,
+    use_detected_locale,
+)
+
+# Common gettext-style alias so call sites can `from code_puppy.i18n import _`.
+_ = t
+
+__all__ = [
+    "_",
+    "t",
+    "ngettext",
+    "lazy",
+    "LazyTranslation",
+    "Translator",
+    "get_translator",
+    "get_locale",
+    "set_locale",
+    "use_detected_locale",
+    "ensure_detected",
+    "detect_locale",
+    "normalize_locale",
+    "fallback_chain",
+    "language_of",
+    "DEFAULT_LOCALE",
+    "plural_category",
+    "format_number",
+    "format_datetime",
+    "add_catalog_dir",
+    "available_locales",
+    "load_catalog",
+    "lookup",
+    "reset",
+    "pseudolocalize",
+    "is_pseudo_locale",
+    "PSEUDO_LOCALE",
+]

code_puppy-0.0.643/code_puppy/i18n/catalog.py

@@ -0,0 +1,213 @@
+"""Message catalog format, loader, and the missing-key fallback chain.
+
+Catalogs are JSON files under ``code_puppy/i18n/locales/<locale>.json`` (plus
+any extra directories registered via :func:`add_catalog_dir`, so plugins and
+the private fork can ship their own strings without editing this package).
+
+Catalog shape::
+
+    {
+      "startup.welcome": "Welcome to Code Puppy, {name}!",
+      "files.deleted": {
+        "one": "Deleted {count} file.",
+        "other": "Deleted {count} files."
+      }
+    }
+
+A value is either a plain string or a plural dict keyed by CLDR plural
+categories (``zero``/``one``/``two``/``few``/``many``/``other``). Only
+``other`` is required in a plural dict; the rest are optional.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import threading
+from typing import Dict, List, Optional, Union
+
+from .locale import DEFAULT_LOCALE, fallback_chain
+
+logger = logging.getLogger(__name__)
+
+# A catalog entry is a bare string or a plural-forms mapping.
+CatalogEntry = Union[str, Dict[str, str]]
+Catalog = Dict[str, CatalogEntry]
+
+# Bundled catalogs ship next to this module.
+_BUILTIN_DIR = os.path.join(os.path.dirname(__file__), "locales")
+
+# Extra directories (plugins, private fork) searched *before* the builtin one,
+# so downstream strings can override or extend the base catalog.
+_extra_dirs: List[str] = []
+
+# locale -> merged catalog. Cleared by reset() / add_catalog_dir().
+_cache: Dict[str, Catalog] = {}
+
+# Bumped whenever the search-dir set changes (reset/add_catalog_dir). A loader
+# that released the lock for file I/O uses this to detect that its result went
+# stale mid-flight and must not poison the cache (see load_catalog).
+_generation = 0
+
+# Guards ALL access to _cache, _extra_dirs, and _generation. lookup() runs on
+# every t() call, which the message queue can dispatch from both the main
+# thread and its daemon thread, so these globals are genuinely shared mutable
+# state.
+_lock = threading.RLock()
+
+# A locale used to build a filename must be a plain BCP-47-ish tag. This is a
+# defense-in-depth guard so the exported load_catalog()/lookup() can't be
+# tricked into path traversal (e.g. "../../../../etc/passwd") even if a caller
+# skips normalize_locale().
+_SAFE_LOCALE_RE = re.compile(r"^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*$")
+
+# Windows reserved device names: open("con.json") resolves to the CON console
+# device (extension ignored), which would hang json.load. normalize_locale
+# happily emits "con"/"nul"/etc. as 3-letter lang subtags, so reject them.
+_WIN_RESERVED = frozenset(
+    {"con", "prn", "aux", "nul"}
+    | {f"com{i}" for i in range(1, 10)}
+    | {f"lpt{i}" for i in range(1, 10)}
+)
+
+
+def _is_safe_locale(locale: str) -> bool:
+    if not locale or _SAFE_LOCALE_RE.match(locale) is None:
+        return False
+    return locale.lower() not in _WIN_RESERVED
+
+
+def add_catalog_dir(path: str) -> None:
+    """Register an additional directory of ``<locale>.json`` catalogs.
+
+    Later-registered dirs win over earlier ones, and all registered dirs win
+    over the builtin catalogs. Registering invalidates the cache.
+    """
+    global _generation
+    with _lock:
+        if path not in _extra_dirs:
+            _extra_dirs.append(path)
+            _cache.clear()
+            _generation += 1
+
+
+def reset() -> None:
+    """Drop cached catalogs (and registered dirs). Mostly for tests."""
+    global _generation
+    with _lock:
+        _cache.clear()
+        _extra_dirs.clear()
+        _generation += 1
+
+
+def _search_dirs() -> List[str]:
+    # Extra dirs are searched last so their entries overwrite the builtins
+    # during the dict merge below. Caller must hold _lock.
+    return [_BUILTIN_DIR, *_extra_dirs]
+
+
+def _is_valid_entry(entry: object) -> bool:
+    """Return whether an untrusted catalog value matches the public schema."""
+    if isinstance(entry, str):
+        return True
+    return (
+        isinstance(entry, dict)
+        and isinstance(entry.get("other"), str)
+        and all(
+            isinstance(category, str) and isinstance(text, str)
+            for category, text in entry.items()
+        )
+    )
+
+
+def _load_file(path: str) -> Catalog:
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            data = json.load(fh)
+    except FileNotFoundError:
+        return {}
+    except (OSError, json.JSONDecodeError) as exc:
+        logger.warning("Skipping malformed i18n catalog %s: %s", path, exc)
+        return {}
+    if not isinstance(data, dict):
+        logger.warning("i18n catalog %s is not a JSON object; skipping", path)
+        return {}
+
+    valid: Catalog = {}
+    for key, entry in data.items():
+        if _is_valid_entry(entry):
+            valid[key] = entry
+        else:
+            logger.warning("Skipping malformed i18n entry %r in catalog %s", key, path)
+    return valid
+
+
+def load_catalog(locale: str) -> Catalog:
+    """Load and merge every ``<locale>.json`` for a single locale.
+
+    Does *not* apply the fallback chain — that happens at lookup time so a
+    key present in ``en`` but absent in ``fr`` still resolves. Cached per
+    locale.
+    """
+    if not _is_safe_locale(locale):
+        # Reject anything that could escape the locales dir (path traversal)
+        # or otherwise isn't a plain locale tag. Defense-in-depth for the
+        # exported API; the normal path already normalizes upstream.
+        logger.warning("Refusing to load unsafe locale name: %r", locale)
+        return {}
+
+    with _lock:
+        cached = _cache.get(locale)
+        if cached is not None:
+            return cached
+        dirs = _search_dirs()
+        gen = _generation
+
+    merged: Catalog = {}
+    for directory in dirs:
+        merged.update(_load_file(os.path.join(directory, f"{locale}.json")))
+
+    with _lock:
+        if gen != _generation:
+            # The dir set changed (reset/add_catalog_dir) while we were doing
+            # file I/O, so ``merged`` may be stale. Return it for this call but
+            # do NOT cache it -- the next call recomputes against current dirs.
+            return merged
+        return _cache.setdefault(locale, merged)
+
+
+def available_locales() -> List[str]:
+    """Return the sorted set of locales that ship a ``<locale>.json`` catalog.
+
+    Scans the builtin dir plus any registered extra dirs. Useful for driving
+    ``/set locale`` autocomplete and for validating the shipped catalogs.
+    """
+    found = set()
+    with _lock:
+        dirs = _search_dirs()
+    for directory in dirs:
+        try:
+            entries = os.listdir(directory)
+        except OSError:
+            continue
+        for name in entries:
+            if name.endswith(".json"):
+                found.add(name[: -len(".json")])
+    return sorted(found)
+
+
+def lookup(
+    key: str, locale: str, default_locale: str = DEFAULT_LOCALE
+) -> Optional[CatalogEntry]:
+    """Find ``key`` walking the locale fallback chain, most-specific first.
+
+    Returns the raw catalog entry (string or plural dict), or ``None`` if the
+    key is absent from every catalog in the chain.
+    """
+    for candidate in fallback_chain(locale, default_locale):
+        entry = load_catalog(candidate).get(key)
+        if entry is not None:
+            return entry
+    return None

code_puppy-0.0.643/code_puppy/i18n/formats.py

@@ -0,0 +1,90 @@
+"""Locale-aware formatting for numbers and dates (stdlib-only, best-effort).
+
+This is the *foundation* seam, not the final implementation. Full CLDR-grade
+formatting (grouping separators per locale, currency, compact "1.2K"
+notation, RTL digit shaping) lands with Babel in a later workstream. For now
+we provide a stable API with sensible en-US-ish defaults and per-locale digit
+grouping/decimal separators for the handful of locales we know we'll hit
+first, so call sites can migrate today without waiting on Babel.
+"""
+
+from __future__ import annotations
+
+from datetime import date, datetime
+from typing import Optional, Union
+
+from .translate import get_locale
+
+# language subtag -> (thousands_sep, decimal_point). Fallback is en-style.
+_SEPARATORS = {
+    "en": (",", "."),
+    "de": (".", ","),
+    "fr": ("\u202f", ","),  # narrow no-break space
+    "es": (".", ","),
+    "it": (".", ","),
+    "pt": (".", ","),
+    "ru": ("\u00a0", ","),
+    "zh": (",", "."),
+    "ja": (",", "."),
+    "ko": (",", "."),
+}
+
+_DEFAULT_SEPARATORS = (",", ".")
+
+
+def _separators(locale: str) -> tuple[str, str]:
+    return _SEPARATORS.get(locale.split("-", 1)[0].lower(), _DEFAULT_SEPARATORS)
+
+
+def format_number(
+    value: Union[int, float],
+    *,
+    decimals: Optional[int] = None,
+    locale: Optional[str] = None,
+) -> str:
+    """Format a number with locale-appropriate grouping/decimal separators.
+
+    Args:
+        value: The number to format.
+        decimals: Fixed number of fraction digits, or ``None`` to keep the
+            value's natural precision (integers render with no fraction).
+        locale: Override the active locale for this call.
+    """
+    loc = locale or get_locale()
+    thousands, decimal_point = _separators(loc)
+
+    if decimals is not None:
+        rendered = f"{value:,.{decimals}f}"
+    elif isinstance(value, int):
+        rendered = f"{value:,d}"
+    else:
+        rendered = f"{value:,}"
+
+    # Python always emits ","/".": swap to locale glyphs via placeholders to
+    # avoid clobbering a separator that happens to equal the other glyph.
+    return (
+        rendered.replace(",", "\0").replace(".", decimal_point).replace("\0", thousands)
+    )
+
+
+def format_datetime(
+    value: Union[datetime, date],
+    *,
+    date_only: bool = False,
+    locale: Optional[str] = None,
+) -> str:
+    """Format a datetime/date. Placeholder ISO-ish output for the foundation.
+
+    Deliberately conservative: ISO-8601 is unambiguous across locales, so we
+    lean on it until Babel provides real CLDR date skeletons. The ``locale``
+    arg is accepted now so call sites don't need to change when the richer
+    implementation lands.
+    """
+    _ = locale or get_locale()  # reserved for the Babel-backed upgrade
+    if date_only or (isinstance(value, date) and not isinstance(value, datetime)):
+        return value.strftime("%Y-%m-%d")
+    rendered = value.strftime("%Y-%m-%d %H:%M")
+    # Don't silently drop the timezone on aware datetimes.
+    if isinstance(value, datetime) and value.tzinfo is not None:
+        rendered += value.strftime("%z")
+    return rendered

code_puppy-0.0.643/code_puppy/i18n/locale.py

@@ -0,0 +1,173 @@
+"""Locale detection, normalization, and the resolution chain.
+
+The active locale is resolved with the following precedence (highest first):
+
+1. ``CODE_PUPPY_LOCALE`` environment variable (explicit override)
+2. The persisted ``locale`` config key (``puppy.cfg``) — the in-app
+   ``/set locale`` preference, which beats the ambient OS locale
+3. POSIX locale env vars: ``LC_ALL`` > ``LC_MESSAGES`` > ``LANG`` > ``LANGUAGE``
+4. The default locale (``en-US``)
+
+Everything here is intentionally stdlib-only. Babel/CLDR-backed niceties
+(full plural rules, currency formatting) arrive in later i18n workstreams;
+the foundation must not drag in a dependency just to boot.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from typing import Optional
+
+DEFAULT_LOCALE = "en-US"
+
+# Env vars checked, in POSIX precedence order, after the explicit override.
+_POSIX_LOCALE_VARS = ("LC_ALL", "LC_MESSAGES", "LANG", "LANGUAGE")
+
+# Matches things like "en", "en_US", "en-US", "en_US.UTF-8", "zh-Hans-CN".
+_LOCALE_RE = re.compile(r"^[A-Za-z]{2,3}(?:[_-][A-Za-z0-9]+)*")
+
+# CLDR parent-locale overrides: locales whose fallback parent is NOT simply
+# their truncated form. The big one for us is Latin American Spanish, where
+# every Central/South American country falls back through the ``es-419``
+# umbrella before reaching generic (Iberian-ish) ``es``.
+#
+# Source: CLDR supplementalData <parentLocales>. Kept as an explicit map so
+# adding a dialect is a one-line change and the behavior is testable.
+_LATIN_AMERICAN_ES = (
+    # Central America (+ Mexico)
+    "es-MX",
+    "es-GT",
+    "es-HN",
+    "es-SV",
+    "es-NI",
+    "es-CR",
+    "es-PA",
+    "es-BZ",
+    # South America
+    "es-AR",
+    "es-BO",
+    "es-CL",
+    "es-CO",
+    "es-EC",
+    "es-PY",
+    "es-PE",
+    "es-UY",
+    "es-VE",
+    # Caribbean + US Spanish (also parented to 419 by CLDR)
+    "es-CU",
+    "es-DO",
+    "es-PR",
+    "es-US",
+)
+PARENT_LOCALES: dict = {loc: "es-419" for loc in _LATIN_AMERICAN_ES}
+PARENT_LOCALES["es-419"] = "es"
+
+
+def normalize_locale(raw: Optional[str]) -> Optional[str]:
+    """Normalize a raw locale string to ``ll-CC`` (or ``ll``) form.
+
+    Strips encoding/modifier suffixes (``.UTF-8``, ``@euro``), converts
+    underscores to hyphens, lowercases the language subtag and uppercases a
+    2-letter region subtag. Returns ``None`` for empty/``"C"``/``"POSIX"``
+    placeholders so callers fall through to the next source.
+    """
+    if not raw:
+        return None
+
+    # Drop encoding (".UTF-8") and modifiers ("@euro").
+    candidate = raw.split(".", 1)[0].split("@", 1)[0].strip()
+    if not candidate or candidate.upper() in ("C", "POSIX"):
+        return None
+
+    match = _LOCALE_RE.match(candidate)
+    if not match:
+        return None
+
+    parts = re.split(r"[_-]", match.group(0))
+    lang = parts[0].lower()
+    if len(parts) == 1:
+        return lang
+
+    tail = parts[1:]
+    # A trailing 2-letter subtag is a region -> uppercase it. Anything else
+    # (e.g. a 4-letter script like "Hans") is title-cased, matching BCP-47.
+    normalized_tail = []
+    for part in tail:
+        if len(part) == 2:
+            normalized_tail.append(part.upper())
+        elif len(part) == 4:
+            normalized_tail.append(part.capitalize())
+        else:
+            normalized_tail.append(part.lower())
+    return "-".join([lang, *normalized_tail])
+
+
+def language_of(locale: str) -> str:
+    """Return the bare language subtag of a locale (``en-US`` -> ``en``)."""
+    return locale.split("-", 1)[0].lower()
+
+
+def fallback_chain(locale: str, default: str = DEFAULT_LOCALE) -> list[str]:
+    """Build the lookup chain for a locale, most-specific first.
+
+    Honors CLDR parent-locale overrides (see :data:`PARENT_LOCALES`), so
+    Latin American Spanish resolves through the ``es-419`` umbrella::
+
+        es-AR  -> ["es-AR", "es-419", "es", "en-US"]
+        zh-Hans-CN -> ["zh-Hans-CN", "zh-Hans", "zh", "en-US"]
+
+    The default locale is always appended last (deduplicated) so a missing
+    key can never escape without at least trying the base catalog.
+    """
+    chain: list[str] = []
+    current: Optional[str] = locale
+    while current and current not in chain:
+        chain.append(current)
+        override = PARENT_LOCALES.get(current)
+        if override:
+            current = override
+        elif "-" in current:
+            current = current.rsplit("-", 1)[0]
+        else:
+            current = None
+    if default not in chain:
+        chain.append(default)
+    return chain
+
+
+def detect_locale(
+    config_value: Optional[str] = None, default: str = DEFAULT_LOCALE
+) -> str:
+    """Resolve the active locale using the full precedence chain.
+
+    Precedence, highest first:
+
+    1. ``CODE_PUPPY_LOCALE`` env var (deliberate, explicit override)
+    2. The persisted ``locale`` config value (the in-app ``/set locale``
+       preference — an explicit user choice beats ambient OS locale, matching
+       git/VS Code/most CLIs)
+    3. POSIX locale env vars (``LC_ALL`` > ``LC_MESSAGES`` > ``LANG`` >
+       ``LANGUAGE``) — ambient OS default
+    4. ``default`` (``en-US``)
+
+    Args:
+        config_value: The persisted ``locale`` config value, if any. Passed
+            in (rather than imported) to keep this module free of a hard
+            dependency on ``code_puppy.config`` and trivially testable.
+        default: Locale to fall back to when nothing else resolves.
+    """
+    override = normalize_locale(os.environ.get("CODE_PUPPY_LOCALE"))
+    if override:
+        return override
+
+    from_config = normalize_locale(config_value)
+    if from_config:
+        return from_config
+
+    for var in _POSIX_LOCALE_VARS:
+        candidate = normalize_locale(os.environ.get(var))
+        if candidate:
+            return candidate
+
+    return normalize_locale(default) or DEFAULT_LOCALE

code_puppy-0.0.643/code_puppy/i18n/locales/en-US.json

@@ -0,0 +1,23 @@
+{
+  "startup.welcome": "Welcome to Code Puppy, {name}!",
+  "startup.ready": "Ready to fetch some code. \ud83d\udc36",
+  "locale.set": "Locale set to {locale}.",
+  "locale.current": "Current locale: {locale}",
+  "files.deleted": {
+    "one": "Deleted {count} file.",
+    "other": "Deleted {count} files."
+  },
+  "files.written": {
+    "one": "Wrote {count} file.",
+    "other": "Wrote {count} files."
+  },
+  "error.generic": "Something went wrong: {detail}",
+  "version.current": "Current version: {version}",
+  "version.latest": "Latest version: {version}",
+  "version.update_available": "A new version of code puppy is available: {version}",
+  "version.please_update": "Please consider updating!",
+  "version.fetch_failed": "Error fetching version: {error}",
+  "version.undetected": "Could not detect current version, using fallback",
+  "confirm.yes": "Yes",
+  "confirm.no": "No"
+}