scootcli 0.1.0__py3-none-any.whl

scootcli/logo.py

@@ -0,0 +1,116 @@
+"""scoot's mascot: one square-head robot on a kick scooter, drawn once and reused everywhere.
+
+Every variant below is the same character in the same pose (one arm on the handlebar, standing on
+the deck, two wheels) so the mascot stays recognisable across the README, the launch banner, the
+status bar and ``/help``. The eyes are the only moving part: they track what the agent is doing.
+
+Variants:
+  * ``banner``  - box-drawing, 5 rows: the REPL launch banner.
+  * ``lean``    - leaning forward with speed lines: ``/logo`` and the README on unicode terminals.
+  * ``micro``   - 3 rows: ``/help`` header and other compact spots.
+  * ``ascii``   - plain ASCII: renders in every font (README fallback).
+
+Nothing here prints or colours; callers decide where the art goes and how it is styled.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, Iterable, List, Tuple
+
+NAME = "scoot"
+LABEL_EMOJI = "🛴"  # U+1F6F4 kick scooter
+LABEL_PLAIN = "⏺"
+
+STATES = ("idle", "thinking", "stopped")
+
+# Eye pairs per state, for the wide (3-cell) face used by banner / lean.
+EYES: Dict[str, str] = {"idle": "o o", "thinking": "> >", "stopped": "- -"}
+
+_ART: Dict[str, Tuple[str, ...]] = {
+    "banner": (
+        "       ╭───╮",
+        "       │{eyes}│",
+        "    T──┤───┤",
+        "    │  ╰┬─┬╯",
+        "  (o)═══╧═╧═(o)",
+    ),
+    "lean": (
+        "          ╭───╮",
+        "        ─ │{eyes}│",
+        "       ─T─┤───┤",
+        "        │ ╰┬─┬╯",
+        "      (o)══╧═╧══(o)",
+    ),
+    "micro": (
+        "       ╭{eyes}╮",
+        "     T─┤   │",
+        " (o)═╧═══════(o)",
+    ),
+    "ascii": (
+        "       .---.",
+        "       |{eyes}|",
+        "    T__|---|",
+        "    |  |_|_|",
+        "  (o)=======(o)",
+    ),
+}
+
+VARIANTS = tuple(_ART)
+
+
+def eyes(state: str = "idle", variant: str = "banner") -> str:
+    """The eye glyphs for ``state``; ``micro``/``ascii`` join them with ``_`` (``o_o``)."""
+    pair = EYES.get(state, EYES["idle"])
+    return pair.replace(" ", "_") if variant in ("micro", "ascii") else pair
+
+
+def mascot(state: str = "idle", variant: str = "banner") -> List[str]:
+    """Rows of the mascot, right-padded to a common width so they compose side by side."""
+    rows = [row.format(eyes=eyes(state, variant)) for row in _ART[variant]]
+    width = max(len(r) for r in rows)
+    return [r.ljust(width) for r in rows]
+
+
+def face(state: str = "idle") -> str:
+    """One-cell-high face for the status bar: ``╭o o╮`` idle, ``╭> >╮`` thinking, ``╭- -╮`` stopped."""
+    return f"╭{eyes(state)}╮"
+
+
+def label(emoji: bool = True) -> str:
+    """The assistant's transcript lead-in: ``🛴 scoot``, or ``⏺ scoot`` where emoji are unwanted."""
+    return f"{LABEL_EMOJI if emoji else LABEL_PLAIN} {NAME}"
+
+
+def tilde(path) -> str:
+    """Show the home directory as ``~`` (banner and status text stay short)."""
+    import os
+
+    p = str(path)
+    home = os.path.expanduser("~")
+    if home and (p == home or p.startswith(home + os.sep)):
+        return "~" + p[len(home):]
+    return p
+
+
+def fit(text: str, width: int) -> str:
+    """Shorten ``text`` to ``width`` cells with a middle ellipsis so both ends stay readable."""
+    if width <= 0 or len(text) <= width:
+        return text
+    if width < 5:
+        return text[:width]
+    head = (width - 1) // 2
+    tail = width - 1 - head
+    return text[:head] + "…" + text[-tail:]
+
+
+def compose(art: Iterable[str], text: Iterable[str], gap: int = 3) -> List[str]:
+    """Place ``text`` rows to the right of ``art`` rows (both top-aligned; the shorter side is padded)."""
+    art, text = list(art), list(text)
+    width = max((len(r) for r in art), default=0)
+    blank = " " * width
+    rows = []
+    for i in range(max(len(art), len(text))):
+        left = art[i] if i < len(art) else blank
+        right = text[i] if i < len(text) else ""
+        rows.append((left + " " * gap + right).rstrip())
+    return rows

scootcli/models.py

@@ -0,0 +1,120 @@
+"""Client-side model resolution for the ``auto`` alias.
+
+Picks a concrete model id from the *live* model list (qualified ``provider/model`` ids) using a
+lightweight, rule-based heuristic: a strong coding model for multi-step/edit tasks, a cheaper/faster
+one for trivial Q&A. Tiers are substring-preference lists so they keep working as model names evolve.
+This heuristic is the seed of the routing provider planned for 0.3.0.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import List
+
+# Preference-ordered substrings. First available match wins.
+# NOTE: tokens are chosen to avoid accidental substring hits (e.g. "mini" ⊂ "geMINI").
+STRONG_TIER = [
+    "gpt-5.3-codex", "codex", "opus", "gpt-5.6", "gpt-5.5", "gpt-5.4", "gpt-5.3", "sonnet", "gpt-4.1",
+    "gpt-4o", "qwen3", "llama3.3", "llama3.1", "llama3.2", "mistral",
+]
+CHEAP_TIER = [
+    "-mini", "-nano", "flash", "haiku", "gpt-4o-mini", "llama3.2", "qwen3", "mistral",
+]
+
+# Markers of small/fast models — the STRONG tier must never pick one of these.
+_SMALL_MARKERS = ("-mini", "flash", "haiku", "nano", "turbo")
+
+# Words that suggest a multi-step / code-changing task (→ strong tier).
+_COMPLEX_HINTS = (
+    "refactor", "implement", "fix", "add ", "create", "edit", "rewrite", "debug",
+    "test", "build", "migrate", "optimize", "generate", "write ", "change", "rename",
+)
+
+
+def looks_complex(text: str) -> bool:
+    t = (text or "").lower()
+    return len(t) > 240 or any(h in t for h in _COMPLEX_HINTS)
+
+
+def _is_small(model_id: str) -> bool:
+    return any(marker in model_id for marker in _SMALL_MARKERS)
+
+
+_SNAPSHOT_RE = re.compile(r"-\d{4}-\d{2}-\d{2}$|-\d{4}$")
+
+
+def is_snapshot(model_id: str) -> bool:
+    """Dated snapshot ids (``gpt-4o-mini-2024-07-18``, ``gpt-4-0613``) lose to their plain alias."""
+    return bool(_SNAPSHOT_RE.search(model_id or ""))
+
+
+def _prefer_plain(available: List[str]) -> List[str]:
+    """Drop snapshot ids when any plain id exists, so tiers pick ``gpt-5-mini`` over a dated variant."""
+    plain = [m for m in available if not is_snapshot(m)]
+    return plain or list(available)
+
+
+def is_chat_model(descriptor: dict) -> bool:
+    caps = descriptor.get("capabilities")
+    ctype = caps.get("type") if isinstance(caps, dict) else None
+    mid = descriptor.get("id", "")
+    if "embedding" in mid:
+        return False
+    return ctype == "chat" or ctype is None
+
+
+# ── Vision (M22) ───────────────────────────────────────────────────────────────
+# Preference-ordered substrings for picking a vision model (seeded from the proven candidate list in
+# First available match wins.
+VISION_TIER = [
+    "gpt-5.3-codex", "gpt-5", "gpt-4.1", "gpt-4o", "claude-sonnet", "claude-opus", "gemini",
+    "qwen2.5vl", "qwen3-vl", "llama3.2-vision", "gemma3", "minicpm-v", "llava", "claude",
+]
+
+# Substring markers of models that are (very likely) vision-capable, used when the /models descriptor
+# doesn't expose an explicit capability flag.
+_VISION_MARKERS = ("gpt-4o", "gpt-4.1", "gpt-5", "claude", "gemini", "vision", "vl", "llava",
+                   "gemma3", "minicpm-v")
+
+
+def is_vision_model(descriptor: dict) -> bool:
+    """True if a /models descriptor looks vision-capable (explicit flag, else a name heuristic)."""
+    caps = descriptor.get("capabilities")
+    if isinstance(caps, dict):
+        supports = caps.get("supports")
+        if isinstance(supports, dict) and supports.get("vision"):
+            return True
+    mid = (descriptor.get("id") or "").lower()
+    return any(marker in mid for marker in _VISION_MARKERS)
+
+
+def resolve_vision(available: List[str], fallback: str = "") -> str:
+    """Choose a vision model id from live ids (VISION_TIER order); ``fallback`` when nothing matches."""
+    ids = [m for m in available if m]
+    if not ids:
+        return fallback
+    for pref in VISION_TIER:
+        for mid in ids:
+            if pref in mid:
+                return mid
+    return fallback if fallback in ids else ids[0]
+
+
+def resolve_auto(task_text: str, available: List[str], fallback: str = "") -> str:
+    """Choose a model id for an ``auto`` request from ``available``; ``fallback`` when the list is empty."""
+    if not available:
+        return fallback
+    available = _prefer_plain(available)
+    if looks_complex(task_text):
+        for pref in STRONG_TIER:
+            for model_id in available:
+                if pref in model_id and not _is_small(model_id):
+                    return model_id
+    else:
+        for pref in CHEAP_TIER:
+            for model_id in available:
+                if pref in model_id:
+                    return model_id
+    # No tier match: fall back to a present model.
+    return fallback if fallback in available else available[0]
+

scootcli/panel.py

@@ -0,0 +1,263 @@
+"""Persistent bottom status bar for the REPL (stdlib-only, TTY-only).
+
+Uses a DECSTBM scroll region so the last terminal row stays pinned while normal output scrolls above
+it. The bar shows the signed-in user, session/folder, model, approval mode, and tokens spent. It is a
+no-op when stdout is not a TTY or when disabled (``SCOOT_PANEL=false`` / ``/panel``).
+"""
+
+from __future__ import annotations
+
+import shutil
+import sys
+from typing import Optional
+
+
+def _fmt_tokens(n: int) -> str:
+    if n >= 1000:
+        return f"{n / 1000:.1f}k"
+    return str(n)
+
+
+class DockLayout:
+    """Shared bottom-dock geometry between the :class:`StatusBar` and the ``LineEditor``.
+
+    The dock reserves a band of rows at the bottom of the terminal, from the top down:
+
+        top pad (1, blank)  ·  input block (``input_rows``, grows as the line wraps)  ·  spacer (1)  ·  bar (1)
+
+    ``input_rows`` is owned by the line editor (it grows/shrinks as the typed line wraps) and read by
+    the status bar when it (re)establishes the DECSTBM scroll region, so the two never disagree. The
+    separation above/below the input is provided by **blank pad rows** (not drawn rules): blanks are
+    immune to terminal-resize width changes and can never leave a smeared artifact in the transcript.
+    All row math lives here so both components compute identical positions.
+    """
+
+    MAX_INPUT_ROWS = 6  # cap the growth; beyond this the input scrolls vertically within the band
+
+    def __init__(self) -> None:
+        self.input_rows = 1
+
+    def reserved(self) -> int:
+        # top pad + input block + spacer + bar
+        return 1 + self.input_rows + 1 + 1
+
+    def region_bottom(self, rows: int) -> int:
+        return max(1, rows - self.reserved())
+
+    def top_pad_row(self, rows: int) -> int:
+        return self.region_bottom(rows) + 1
+
+    def input_top(self, rows: int) -> int:
+        return self.top_pad_row(rows) + 1
+
+    def input_bottom(self, rows: int) -> int:
+        return self.input_top(rows) + self.input_rows - 1
+
+    def spacer_row(self, rows: int) -> int:
+        return self.input_bottom(rows) + 1
+
+    def bar_row(self, rows: int) -> int:
+        return rows
+
+
+def build_status_text(session, user: Optional[str] = None) -> str:
+    """Compose the status-bar text from the live session (pure; unit-testable)."""
+    import os
+
+    folder = os.path.basename(str(session.config.root).rstrip("/")) or str(session.config.root)
+    short_id = session.id.split("-")[-1] if getattr(session, "id", "") else "?"
+    model = session.active_model or session.resolved_model()
+    if session.model.lower() == "auto":
+        model += " (auto)"
+    spent = session.total_prompt + session.total_completion
+    ctx = int((getattr(session, "last_usage", None) or {}).get("prompt_tokens", 0) or 0)
+    if not ctx:
+        try:
+            from .context import estimate_messages_tokens
+
+            ctx = estimate_messages_tokens(getattr(session, "messages", None))
+        except Exception:
+            ctx = 0
+    # Context as a share of the auto-compact threshold — a heads-up that a /compact is coming. Warn
+    # (△) once we cross 80% so the user can /compact on their own terms first.
+    limit = int(getattr(getattr(session, "config", None), "compact_at", 0) or 0)
+    ctx_seg = f"▤ ctx {_fmt_tokens(ctx)}"
+    if limit > 0:
+        pct = min(999, int(round(ctx * 100 / limit)))
+        ctx_seg = f"{'△' if pct >= 80 else '▤'} ctx {_fmt_tokens(ctx)} ({pct}%)"
+    ctx_seg += f" · Σ {_fmt_tokens(spent)} tok"
+    segments = [
+        f"⏻ {user}" if user else "⏻ signed in",
+        f"⌂ {folder}·{short_id}",
+        f"⚙ {model}",
+        f"◈ {session.approval_mode}",
+        ctx_seg,
+    ]
+    msgs = getattr(session, "messages", None)
+    if msgs:
+        segments.append(f"✉ {len(msgs)}")
+    if getattr(session, "worktree", None) is not None:
+        segments.append(f"⑂ {session.worktree.branch}")
+    plan = getattr(session, "plan", None)
+    if plan:
+        done = sum(1 for s in plan if s.get("status") == "completed")
+        segments.append(f"◇ {done}/{len(plan)}")
+    err = getattr(session, "last_error", None)
+    if err:
+        segments.append(f"⚠ {err}")
+    # The mascot's face leads the bar; its eyes follow the turn (idle / thinking / stopped).
+    if getattr(getattr(session, "config", None), "logo", True):
+        from .logo import face
+
+        segments.insert(0, face(getattr(session, "mascot_state", "idle")))
+    return "  │  ".join(segments)
+
+
+class StatusBar:
+    """A pinned bottom bar. Safe no-op when not a TTY or disabled.
+
+    When ``reserve_input`` is set (the REPL "dock", PLAN §19), rows are reserved just above the bar for
+    a fixed input line owned by :class:`~scootcli.lineeditor.LineEditor`. With a :class:`DockLayout` the
+    input can span **multiple rows** (a wrapping line) framed by blank pad rows above and below; the bar
+    reads ``layout.input_rows`` when it (re)establishes the scroll region, and blanks the pad/spacer and
+    draws the bar (the input rows themselves are owned by the editor). :meth:`reflow` lets the editor
+    grow/shrink that region mid-edit without disturbing its own saved cursor.
+    """
+
+    def __init__(self, enabled: bool = True, reserve_input: bool = False, layout=None):
+        self.enabled = enabled and sys.stdout.isatty()
+        self.reserve_input = reserve_input
+        self.layout = layout  # DockLayout when the multi-row dock is active; None = legacy single row
+        self._installed = False
+        self._rows = 0
+        self._reserved_cache = -1
+        self._text = ""
+
+    # ── lifecycle ────────────────────────────────────────────────────────────────
+    def install(self) -> None:
+        if not self.enabled or self._installed:
+            return
+        self._rows = self._term_rows()
+        # Reserve the bottom rows: a blank spacer + [optional input row] + the bar. The scroll region
+        # is 1..region_bottom, so output never butts up against (or overwrites) the reserved rows. Home
+        # the cursor so whatever prints next (the banner) starts at the top and flows down.
+        sys.stdout.write(f"\033[1;{self._region_bottom(self._rows)}r")
+        sys.stdout.write("\033[1;1H")
+        sys.stdout.flush()
+        self._installed = True
+
+    def render(self, text: Optional[str] = None) -> None:
+        """Redraw the bar (recomputes size so it self-heals after a resize)."""
+        if not self.enabled:
+            return
+        if text is not None:
+            self._text = text
+        rows = self._term_rows()
+        reserved = self._reserved()
+        sys.stdout.write("\0337")  # save cursor + attrs (DECSC)
+        if not self._installed or rows != self._rows or reserved != self._reserved_cache:
+            self._rows = rows
+            self._reserved_cache = reserved
+            sys.stdout.write(f"\033[1;{self._region_bottom(rows)}r")  # (re)establish scroll region
+            self._installed = True
+        self._draw_frame(rows)
+        sys.stdout.write("\0338")  # restore cursor (DECRC)
+        sys.stdout.flush()
+
+    def reflow(self) -> None:
+        """Re-establish the scroll region + redraw the frame for the current ``layout.input_rows``.
+
+        Unlike :meth:`render`, this does **not** use the DECSC/DECRC save slot — it is called by the
+        line editor *while editing*, which owns that slot for its own final cursor restore. The caller
+        repositions the caret afterwards, so we may leave the cursor anywhere.
+        """
+        if not self.enabled:
+            return
+        rows = self._term_rows()
+        self._rows = rows
+        self._reserved_cache = self._reserved()
+        self._installed = True
+        sys.stdout.write(f"\033[1;{self._region_bottom(rows)}r")  # (re)establish for the new height
+        self._draw_frame(rows)
+        # no flush — the editor flushes after drawing the input rows + caret
+
+    def set_text(self, text: str) -> None:
+        """Update the cached bar text without emitting anything (used before :meth:`reflow`)."""
+        self._text = text
+
+
+    def _draw_frame(self, rows: int) -> None:
+        """Draw the non-input reserved rows: the top pad (if docked), the spacer, and the bar.
+
+        The pad + spacer are kept **blank** (just erased) rather than drawn with rule glyphs, so they
+        are immune to resize width changes and never leave an artifact when the region scrolls.
+        """
+        cols = self._term_cols()
+        bar = self._text[: cols - 2]
+        if self.layout is not None:
+            sys.stdout.write(f"\033[{self.layout.top_pad_row(rows)};1H\033[K")  # blank pad above input
+        # Keep the spacer row blank (the input row(s), if reserved, are owned by the editor — never
+        # touched here), then draw the bar on the fixed bottom row in reverse video.
+        sys.stdout.write(f"\033[{self._spacer_row(rows)};1H\033[K")
+        sys.stdout.write(f"\033[{rows};1H\033[K\033[7m {bar} \033[0m")
+
+    def remove(self) -> None:
+        if not self.enabled or not self._installed:
+            return
+        rows = self._term_rows()
+        sys.stdout.write("\033[r")  # reset scroll region to full screen
+        # Clear the whole reserved band (pad + input rows + spacer + bar) so nothing lingers.
+        if self.layout is not None:
+            top = self.layout.top_pad_row(rows)
+        elif self.reserve_input:
+            top = rows - 2  # legacy: spacer, input, bar
+        else:
+            top = rows - 1  # spacer, bar
+        for r in range(top, rows + 1):
+            sys.stdout.write(f"\033[{r};1H\033[K")
+        sys.stdout.flush()
+        self._installed = False
+
+
+    def toggle(self) -> bool:
+        """Flip enabled state (install/remove accordingly). Returns the new state."""
+        if self._installed:
+            self.remove()
+            self.enabled = False
+        else:
+            self.enabled = sys.stdout.isatty()
+            # render() re-establishes the scroll region inside a cursor save/restore, so re-enabling
+            # mid-session doesn't jump the cursor the way install() (which homes it) would.
+            self.render(self._text)
+        return self.enabled
+
+    # ── internals ────────────────────────────────────────────────────────────────
+    def _reserved(self) -> int:
+        # Rows kept out of the scroll region. With a DockLayout the input block grows, so defer to it
+        # (rule + input_rows + spacer + bar). Legacy paths: spacer + bar, plus one input row if docked.
+        if self.layout is not None:
+            return self.layout.reserved()
+        return 3 if self.reserve_input else 2
+
+    def _region_bottom(self, rows: int) -> int:
+        # Bottom row of the scroll region (guard tiny terminals).
+        if self.layout is not None:
+            return self.layout.region_bottom(rows)
+        return max(1, rows - self._reserved())
+
+    def _spacer_row(self, rows: int) -> int:
+        # The blank separator sits just below the input block (or the scroll region when not docked).
+        if self.layout is not None:
+            return self.layout.spacer_row(rows)
+        return self._region_bottom(rows) + 1
+
+    @staticmethod
+    def _term_rows() -> int:
+        return shutil.get_terminal_size((80, 24)).lines
+
+    @staticmethod
+    def _term_cols() -> int:
+        return shutil.get_terminal_size((80, 24)).columns
+
+
+

scootcli/preferences.py

@@ -0,0 +1,87 @@
+"""Persisted user preferences (the chosen model, the mascot toggle), surviving across launches.
+
+Unlike sessions (per-directory conversations), this is a single *global* preference file at
+``~/.config/scoot/preferences.json``. Writing is best-effort — a failure never breaks the CLI.
+``SCOOT_CONFIG_DIR`` overrides the location (used by tests).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+from .config import SCOOT_CONFIG_DIR
+
+
+def _config_dir() -> Path:
+    override = os.environ.get("SCOOT_CONFIG_DIR")
+    return Path(override).expanduser() if override else SCOOT_CONFIG_DIR
+
+
+def _prefs_file() -> Path:
+    return _config_dir() / "preferences.json"
+
+
+def load_preferences() -> dict:
+    try:
+        data = json.loads(_prefs_file().read_text())
+        return data if isinstance(data, dict) else {}
+    except (OSError, json.JSONDecodeError, ValueError):
+        return {}
+
+
+def _write(prefs: dict) -> None:
+    directory = _config_dir()
+    try:
+        directory.mkdir(parents=True, exist_ok=True)
+        try:
+            os.chmod(directory, 0o700)
+        except OSError:
+            pass
+        path = _prefs_file()
+        tmp = directory / ".preferences.tmp"
+        fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(fd, "w") as fh:
+            json.dump(prefs, fh)
+        os.replace(tmp, path)  # atomic
+    except OSError:
+        pass  # preferences are best-effort
+
+
+def save_preference(key: str, value) -> None:
+    prefs = load_preferences()
+    if value is None:
+        prefs.pop(key, None)
+    else:
+        prefs[key] = value
+    _write(prefs)
+
+
+# ── model preference ────────────────────────────────────────────────────────────
+def get_model() -> Optional[str]:
+    model = load_preferences().get("model")
+    return model or None
+
+
+def set_model(name: str) -> None:
+    """Persist the chosen model (including ``auto``) so the next launch reuses it."""
+    save_preference("model", name)
+
+
+def clear_model() -> None:
+    save_preference("model", None)
+
+
+# ── mascot preference ───────────────────────────────────────────────────────────
+def get_logo() -> Optional[bool]:
+    """``True``/``False`` if the user chose via ``/logo on|off``; ``None`` when unset (default on)."""
+    value = load_preferences().get("logo")
+    return value if isinstance(value, bool) else None
+
+
+def set_logo(on: Optional[bool]) -> None:
+    """Persist the mascot toggle (``None`` forgets it → back to the default)."""
+    save_preference("logo", on)
+

scootcli/presets.py

@@ -0,0 +1,38 @@
+"""CLI preset shortcuts (PLAN §6). Optional sugar that seed the agent with a task string.
+
+Each preset is ``fn(paths, message) -> str`` returning the seed prompt. Adding a preset = add an entry
+to :data:`PRESETS`. These are pure convenience — every preset is expressible as a plain prompt.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Dict, List, Optional
+
+
+def _explain(paths: List[str], message: Optional[str]) -> str:
+    target = " ".join(paths) if paths else "the current directory"
+    extra = f" Focus: {message}." if message else ""
+    return (f"Explain {target}: summarize its purpose, key parts, and how to use it."
+            f" Read files as needed; do not modify anything.{extra}")
+
+
+def _edit(paths: List[str], message: Optional[str]) -> str:
+    target = " ".join(paths) if paths else "the relevant file(s)"
+    instruction = message or "make the requested change"
+    return f"Edit {target}: {instruction}"
+
+
+# name -> (seed builder, needs_message)
+PRESETS: Dict[str, "Callable[[List[str], Optional[str]], str]"] = {
+    "explain": _explain,
+    "edit": _edit,
+}
+
+
+def is_preset(word: str) -> bool:
+    return word in PRESETS
+
+
+def build_prompt(name: str, rest: List[str], message: Optional[str]) -> str:
+    return PRESETS[name](rest, message)
+