seedcode-cli 6.1.5__py3-none-any.whl

seedcode/ui/theme.py

@@ -0,0 +1,204 @@
+"""Seed Code theme system.
+
+Multiple named palettes share one branding contract: a primary tone, an
+accent, dim/text/warning/error/success roles, and a cursor-row background
+for the interactive selector. The default "seed" palette is the classic
+Seed Green identity; every other theme keeps the same structure so all
+components render correctly under any of them.
+
+Both rendering stacks read from here:
+
+* Rich  — :func:`rich_theme` builds a :class:`rich.theme.Theme` with the
+  ``seed.*`` style names used across the app.
+* prompt_toolkit — :func:`pt_style` builds the ``sel.*`` style classes used
+  by the interactive components in :mod:`seedcode.ui.selector` and friends.
+
+The active theme is module-level state set from config at startup and by
+the theme picker; components query it at render time so a theme switch is
+instant everywhere.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from prompt_toolkit.styles import Style
+from rich.theme import Theme
+
+
+@dataclass(frozen=True)
+class Palette:
+    """One named colour palette (all values are hex strings)."""
+
+    id: str
+    label: str
+    description: str
+    primary: str
+    accent: str
+    text: str
+    dim: str
+    warning: str
+    error: str
+    success: str
+    cursor_bg: str  # selector highlighted-row background
+
+
+PALETTES: dict[str, Palette] = {
+    p.id: p
+    for p in (
+        Palette(
+            id="seed",
+            label="Seed Green",
+            description="The classic Seed Code identity",
+            primary="#2ecc71",
+            accent="#7bed9f",
+            text="#ffffff",
+            dim="#9e9e9e",
+            warning="#f1c40f",
+            error="#e74c3c",
+            success="#2ecc71",
+            cursor_bg="#1d3b2a",
+        ),
+        Palette(
+            id="forest",
+            label="Forest",
+            description="Deep greens and moss",
+            primary="#27ae60",
+            accent="#a3e4b8",
+            text="#e8f5e9",
+            dim="#7d8f84",
+            warning="#e6c229",
+            error="#e74c3c",
+            success="#27ae60",
+            cursor_bg="#16301f",
+        ),
+        Palette(
+            id="ocean",
+            label="Ocean",
+            description="Calm blues and cyan",
+            primary="#3498db",
+            accent="#7fd6f2",
+            text="#eaf6fb",
+            dim="#8496a3",
+            warning="#f1c40f",
+            error="#e74c3c",
+            success="#2ecc71",
+            cursor_bg="#14303f",
+        ),
+        Palette(
+            id="dusk",
+            label="Dusk",
+            description="Violet evening tones",
+            primary="#9b59b6",
+            accent="#d2a8e0",
+            text="#f5eefa",
+            dim="#988fa3",
+            warning="#f1c40f",
+            error="#e74c3c",
+            success="#2ecc71",
+            cursor_bg="#2d1f38",
+        ),
+        Palette(
+            id="ember",
+            label="Ember",
+            description="Warm amber and orange",
+            primary="#e67e22",
+            accent="#f5b971",
+            text="#fdf3e7",
+            dim="#a3937f",
+            warning="#f1c40f",
+            error="#e74c3c",
+            success="#2ecc71",
+            cursor_bg="#3a2712",
+        ),
+        Palette(
+            id="mono",
+            label="Monochrome",
+            description="Plain white on black",
+            primary="#ffffff",
+            accent="#c8c8c8",
+            text="#ffffff",
+            dim="#808080",
+            warning="#f1c40f",
+            error="#e74c3c",
+            success="#ffffff",
+            cursor_bg="#333333",
+        ),
+    )
+}
+
+DEFAULT_THEME = "seed"
+
+# Module-level active theme (set from config at startup, and live by the
+# theme picker). Components read it at render time.
+_active: str = DEFAULT_THEME
+
+
+def set_active_theme(name: str) -> Palette:
+    """Set the active theme (unknown names fall back to the default)."""
+    global _active
+    _active = name if name in PALETTES else DEFAULT_THEME
+    return PALETTES[_active]
+
+
+def active_theme_name() -> str:
+    return _active
+
+
+def active_palette() -> Palette:
+    return PALETTES.get(_active, PALETTES[DEFAULT_THEME])
+
+
+def rich_theme(name: str | None = None) -> Theme:
+    """Rich theme with the ``seed.*`` styles used across the app."""
+    p = PALETTES.get(name or _active, PALETTES[DEFAULT_THEME])
+    return Theme(
+        {
+            "seed.primary": f"bold {p.primary}",
+            "seed.accent": p.accent,
+            "seed.text": p.text,
+            "seed.dim": p.dim,
+            "seed.warning": p.warning,
+            "seed.error": f"bold {p.error}",
+            "seed.success": p.success,
+            "seed.prompt": f"bold {p.primary}",
+            "seed.assistant": p.accent,
+            "markdown.code": p.accent,
+        }
+    )
+
+
+def pt_style(name: str | None = None) -> Style:
+    """prompt_toolkit style with the ``sel.*`` classes the components use."""
+    p = PALETTES.get(name or _active, PALETTES[DEFAULT_THEME])
+    return Style.from_dict(
+        {
+            "prompt": f"bold {p.primary}",
+            "sel.title": f"bold {p.primary}",
+            "sel.breadcrumb": p.dim,
+            "sel.breadcrumb.here": f"bold {p.accent}",
+            "sel.searchlabel": f"bold {p.primary}",
+            "sel.query": p.text,
+            "sel.placeholder": f"italic {p.dim}",
+            "sel.pointer": f"bold {p.primary}",
+            "sel.cursorline": f"bg:{p.cursor_bg}",
+            "sel.text": p.text,
+            "sel.dim": p.dim,
+            "sel.match": f"bold underline {p.accent}",
+            "sel.group": f"bold {p.accent}",
+            "sel.hint": p.dim,
+            "sel.counter": p.dim,
+            "sel.ok": p.success,
+            "sel.warn": p.warning,
+            "sel.err": f"bold {p.error}",
+            "sel.off": p.dim,
+            "sel.scroll": p.dim,
+            "sel.swatch.primary": f"bg:{p.primary}",
+            "sel.swatch.accent": f"bg:{p.accent}",
+            "sel.swatch.dim": f"bg:{p.dim}",
+        }
+    )
+
+
+# Backwards-compatible export: the classic Seed Green Rich theme.
+SEED_THEME = rich_theme(DEFAULT_THEME)

seedcode/ui/tree.py

@@ -0,0 +1,91 @@
+"""Nested navigation trees: settings screens with breadcrumbs.
+
+A :class:`TreeNode` is either a branch (children) or a leaf (an action
+callback). :func:`navigate` walks the tree with the interactive selector,
+showing a ``Settings › Providers › FreeModel Claude`` breadcrumb at every
+level. Esc goes up one level; Esc at the root exits. Leaf callbacks return
+True to stay on the current level (so a value edit refreshes in place) or
+False/None to exit the whole tree.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable, Sequence
+
+from .selector import Option, select
+
+
+@dataclass
+class TreeNode:
+    """One navigable node.
+
+    Branches set ``children`` (static) or ``build`` (computed per visit so
+    live values stay fresh). Leaves set ``action``. ``status`` is the dimmed
+    current-value column shown next to the label.
+    """
+
+    label: str
+    children: Sequence["TreeNode"] = field(default_factory=tuple)
+    build: Callable[[], Sequence["TreeNode"]] | None = None
+    action: Callable[[], object] | None = None
+    status: str = ""
+    status_fn: Callable[[], str] | None = None
+    badge: str = ""
+
+    def resolve_children(self) -> Sequence["TreeNode"]:
+        if self.build is not None:
+            return self.build()
+        return self.children
+
+    def resolve_status(self) -> str:
+        if self.status_fn is not None:
+            try:
+                return self.status_fn()
+            except Exception:
+                return ""
+        return self.status
+
+
+def navigate(root: TreeNode, *, breadcrumbs: Sequence[str] = ()) -> None:
+    """Walk ``root`` interactively until the user backs out of the top level."""
+    trail = list(breadcrumbs) or [root.label]
+    _navigate_level(root, trail)
+
+
+def _navigate_level(node: TreeNode, trail: list[str]) -> bool:
+    """Show one level; returns False when the whole tree should exit."""
+    last = None
+    while True:
+        children = list(node.resolve_children())
+        if not children:
+            return True
+        options = [
+            Option(
+                child.label,
+                value=i,
+                columns=(child.resolve_status(),) if child.resolve_status() else (),
+                badge=child.badge,
+            )
+            for i, child in enumerate(children)
+        ]
+        chosen = select(
+            options,
+            breadcrumbs=trail,
+            hint="↑↓ move   Enter open   Esc back",
+            initial=last,
+        )
+        if chosen is None:
+            return True  # Esc: up one level
+        last = chosen
+        child = children[int(chosen)]
+        if child.action is not None:
+            try:
+                keep = child.action()
+            except (KeyboardInterrupt, EOFError):
+                keep = True
+            if keep is False:
+                return False
+            continue
+        if not _navigate_level(child, trail + [child.label]):
+            return False

seedcode/utils/__init__.py

@@ -0,0 +1,22 @@
+"""Utility helpers: filesystem paths, timestamps, and logging."""
+
+from __future__ import annotations
+
+from .helpers import (
+    app_dir,
+    config_path,
+    history_dir,
+    restrict_permissions,
+    session_id,
+)
+from .logger import get_logger, setup_logging
+
+__all__ = [
+    "app_dir",
+    "config_path",
+    "get_logger",
+    "history_dir",
+    "restrict_permissions",
+    "session_id",
+    "setup_logging",
+]

seedcode/utils/helpers.py

@@ -0,0 +1,97 @@
+"""Small shared helpers for Seed Code.
+
+Kept dependency-light so importing this module stays cheap during startup.
+"""
+
+from __future__ import annotations
+
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+
+def app_dir() -> Path:
+    """Return the per-user Seed Code directory, creating it if needed.
+
+    Uses ``~/.seedcode`` on every platform for predictable, cross-platform
+    behaviour (Windows PowerShell, Linux, macOS). If the home directory is
+    unwritable (locked-down corporate machines), falls back to a temp
+    location so the app still starts.
+    """
+    path = Path.home() / ".seedcode"
+    try:
+        path.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        path = Path(tempfile.gettempdir()) / "seedcode"
+        path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def bundled_path(*parts: str) -> Path:
+    """Resolve a read-only asset that ships with Seed Code.
+
+    Works in both modes the app runs in:
+
+    * **frozen** (the PyInstaller one-file exe) — data files are unpacked to a
+      temp directory exposed as ``sys._MEIPASS``;
+    * **source / pip** — assets sit inside the installed ``seedcode`` package.
+
+    The path is returned whether or not it exists; callers decide what a
+    missing asset means.
+    """
+    if getattr(sys, "frozen", False):
+        base = Path(getattr(sys, "_MEIPASS", "") or Path(sys.executable).parent)
+    else:
+        base = Path(__file__).resolve().parents[1]  # -> seedcode/
+    return base.joinpath(*parts)
+
+
+def install_dir() -> Path:
+    """The directory Seed Code is installed in (next to the exe when frozen).
+
+    Distinct from :func:`bundled_path`: the Windows installer places large
+    payloads beside ``seedcode.exe`` rather than inside it, so they survive as
+    real files instead of being unpacked on every launch.
+    """
+    if getattr(sys, "frozen", False):
+        return Path(sys.executable).resolve().parent
+    return Path(__file__).resolve().parents[2]
+
+
+def config_path() -> Path:
+    """Path to the JSON configuration file."""
+    return app_dir() / "config.json"
+
+
+def history_dir(provider_id: str = "") -> Path:
+    """Directory holding saved conversation transcripts.
+
+    Each provider keeps its own history under ``history/<provider_id>/`` so
+    switching backends never mixes conversations.
+    """
+    path = app_dir() / "history"
+    if provider_id:
+        path = path / provider_id
+    try:
+        path.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        pass  # history is best-effort; callers already tolerate write failures
+    return path
+
+
+def restrict_permissions(path: Path) -> None:
+    """Best-effort: make a file readable/writable by the owner only.
+
+    On Windows this is a no-op (POSIX perms are ignored) but it never raises,
+    so callers can invoke it unconditionally.
+    """
+    try:
+        path.chmod(0o600)
+    except (OSError, NotImplementedError):
+        pass
+
+
+def session_id() -> str:
+    """Generate a filesystem-safe id for a chat session."""
+    return time.strftime("%Y%m%d-%H%M%S", time.localtime())

seedcode/utils/logger.py

@@ -0,0 +1,65 @@
+"""Logging for Seed Code.
+
+Seed Code is a quiet CLI: nothing is ever logged to the terminal. Instead a
+rotating file under ``~/.seedcode/logs/seedcode.log`` records startup, config
+loading, API request metadata and errors so problems can be diagnosed after
+the fact. API keys and message content are never logged.
+
+Set ``SEEDCODE_DEBUG=1`` to raise the file log level from INFO to DEBUG.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from logging.handlers import RotatingFileHandler
+
+_ROOT = "seedcode"
+_configured = False
+
+# Keep the log small: two 512 KB files at most.
+_MAX_BYTES = 512 * 1024
+_BACKUP_COUNT = 1
+
+
+def setup_logging() -> None:
+    """Attach the rotating file handler once. Never raises, never prints."""
+    global _configured
+    if _configured:
+        return
+    _configured = True
+
+    root = logging.getLogger(_ROOT)
+    root.setLevel(logging.DEBUG)
+    # Terminal stays silent even if no file handler could be attached.
+    root.addHandler(logging.NullHandler())
+    root.propagate = False
+
+    try:
+        # Imported here so importing this module stays dependency-light.
+        from .helpers import app_dir
+
+        log_dir = app_dir() / "logs"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        handler = RotatingFileHandler(
+            log_dir / "seedcode.log",
+            maxBytes=_MAX_BYTES,
+            backupCount=_BACKUP_COUNT,
+            encoding="utf-8",
+        )
+        debug = os.environ.get("SEEDCODE_DEBUG", "").strip() not in ("", "0")
+        handler.setLevel(logging.DEBUG if debug else logging.INFO)
+        handler.setFormatter(
+            logging.Formatter("%(asctime)s %(levelname)-7s %(name)s: %(message)s")
+        )
+        root.addHandler(handler)
+    except OSError:
+        # A read-only or full disk must never stop the app from starting.
+        pass
+
+
+def get_logger(name: str = _ROOT) -> logging.Logger:
+    """Return a namespaced logger (silent until :func:`setup_logging` runs)."""
+    if not name.startswith(_ROOT):
+        name = f"{_ROOT}.{name}"
+    return logging.getLogger(name)