scootcli 0.1.0__py3-none-any.whl

scootcli/cli.py

@@ -0,0 +1,276 @@
+"""scoot command-line entrypoint.
+
+Usage:
+  * ``scoot``                       — open the interactive REPL (banner, ESC-interrupt, slash-cmds)
+  * ``scoot "a prompt"``            — one-shot agentic turn (tools + approvals), then exit
+  * ``scoot explain <path>``        — preset: explain file(s) (read-only)
+  * ``scoot edit <path> -m "..."``  — preset: edit file(s) with an instruction
+  * ``scoot models [--provider X]`` — list available models (per provider)
+  * ``scoot auth [set|clear <provider>]`` — show provider keys, or save / forget one
+
+Global flags override config: ``--model``, ``--proxy``, ``--root``,
+``--approval``/``--yolo``, ``--verbose``, ``--json``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json as _json
+import sys
+from typing import List, Optional
+
+from .providers import ProviderPool
+from . import __version__
+from .config import Config
+from .errors import ScootError
+from .rendering import color, eprint, redact
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="scoot",
+        description="scoot: a tiny coding agent that goes where you point it.",
+    )
+    # Global flags (CLI-flag layer of config precedence).
+    parser.add_argument("--version", action="version", version=f"scoot {__version__}")
+    parser.add_argument("--model", help="Model as provider/model (e.g. openai/gpt-5.3-codex), 'default', or 'auto'.")
+    parser.add_argument("--provider", help="Default provider (openai, ollama, ...) for bare model names.")
+    parser.add_argument("--effort", choices=["low", "medium", "high", "xhigh"],
+                        help="Reasoning effort for models that support it (default medium).")
+    parser.add_argument("--proxy", help="HTTPS proxy URL.")
+    parser.add_argument("--root", help="Workspace root directory.")
+    parser.add_argument("--approval", choices=["always", "auto-read", "auto-edits", "yolo"],
+                        help="Approval mode for tool calls.")
+    parser.add_argument("--yolo", action="store_true", help="Auto-approve all tool calls (shortcut).")
+    parser.add_argument("--yes", "-y", action="store_true",
+                        help="Auto-approve all tool calls for this run (handy for one-shot/scripted use).")
+    parser.add_argument("-m", "--message", help="Instruction for 'edit' / focus for 'explain'.")
+    parser.add_argument("--json", action="store_true", help="Machine-readable output (models / one-shot).")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output.")
+    parser.add_argument("--no-stream", action="store_true",
+                        help="Disable live token streaming (wait for the full response).")
+    parser.add_argument("--no-panel", action="store_true",
+                        help="Disable the persistent bottom status bar in the REPL.")
+    parser.add_argument("--no-dock", action="store_true",
+                        help="Disable the fixed bottom input line (use a plain inline prompt).")
+    parser.add_argument("--vision", action="store_true",
+                        help="With 'models': list only vision-capable models.")
+    parser.add_argument("--no-workspace", action="store_true",
+                        help="Don't inject the repo map (git + file tree) into the agent prompt.")
+    parser.add_argument("--no-labels", action="store_true",
+                        help="Hide the role labels/gutters (❯ you / ⏺ scoot) in the REPL transcript.")
+    parser.add_argument("--no-logo", action="store_true",
+                        help="Hide the mascot (launch banner art + status-bar face). Persist with /logo off.")
+    parser.add_argument("--no-emoji", action="store_true",
+                        help="Use the plain ⏺ transcript label instead of 🛴 (terminals without emoji).")
+    parser.add_argument("--no-images", action="store_true",
+                        help="Don't detect/describe image files dropped into the prompt.")
+    parser.add_argument("--vision-model",
+                        help="Vision model id for describing dropped images (or 'auto').")
+    parser.add_argument("-c", "--continue", dest="continue_latest", action="store_true",
+                        help="Resume the most recent session for this directory.")
+    parser.add_argument("--resume", metavar="ID", help="Resume a specific saved session by id.")
+    parser.add_argument("--resume-last", action="store_true",
+                        help="Auto-resume the latest session for this directory on launch (resume=auto).")
+
+    # Positional: a reserved word ('models'), a preset ('explain'/'edit'), or a free-form prompt.
+    parser.add_argument(
+        "prompt",
+        nargs="*",
+        help="A prompt, the word 'models', or a preset ('explain <path>' / 'edit <path> -m ...').",
+    )
+    return parser
+
+
+def _config_from_args(args: argparse.Namespace) -> Config:
+    return Config.load().override(
+        model=args.model,
+        provider=args.provider,
+        effort=args.effort,
+        proxy=args.proxy,
+        root=args.root,
+        approval="yolo" if (args.yolo or args.yes) else args.approval,
+        verbose=True if args.verbose else None,
+        stream=False if args.no_stream else None,
+        panel=False if args.no_panel else None,
+        dock=False if args.no_dock else None,
+        resume="auto" if args.resume_last else None,
+        workspace_context=False if args.no_workspace else None,
+        labels=False if args.no_labels else None,
+        images=False if args.no_images else None,
+        logo=False if args.no_logo else None,
+        emoji=False if args.no_emoji else None,
+        vision_model=args.vision_model,
+    )
+
+
+def _cmd_models(pool: ProviderPool, as_json: bool, vision_only: bool = False,
+                provider: Optional[str] = None) -> int:
+    models = pool.list_models(provider=provider)
+    if vision_only:
+        from .models import is_vision_model
+
+        models = [m for m in models if is_vision_model({"id": m.id, **m.raw})]
+    if as_json:
+        print(_json.dumps({
+            "models": [{"id": m.id, "provider": m.provider, "name": m.name} for m in models],
+            "errors": {k: redact(v) for k, v in pool.list_errors.items()},
+        }, indent=2))
+        return 0
+    for name, err in sorted(pool.list_errors.items()):
+        eprint(color(f"⚠ {name}: {redact(err)}", "yellow"))
+    if not models:
+        print("No models returned.")
+        return 0
+    by_provider: dict = {}
+    for m in models:
+        by_provider.setdefault(m.provider, []).append(m)
+    default = pool.default_name
+    for name in sorted(by_provider):
+        tag = "  (default)" if name == default else ""
+        print(color(f"{name}{tag}", "bold"))
+        for m in sorted(by_provider[name], key=lambda x: x.name):
+            print(f"  {color(m.id, 'cyan')}")
+    return 0
+
+
+def _run_once(config: Config, pool: ProviderPool, prompt: str, as_json: bool, resume=None) -> int:
+    """Run a single agentic turn (tools + approvals) and print the result, then exit."""
+    import threading
+
+    from .agent import Agent
+    from .repl import ReplSession, ReplUI
+
+    session = ReplSession(config, pool)
+    if resume is not None:
+        session.apply_record(resume)
+    # Fold any dropped image paths into the prompt (best-effort; no-op when none/disabled).
+    try:
+        from .vision import fold_images_into_text
+
+        prompt = fold_images_into_text(prompt, config, pool)
+    except Exception:
+        pass
+    session.messages.append({"role": "user", "content": prompt})
+    # JSON output must be clean, so never stream tokens to stdout in that mode.
+    agent_config = config.override(stream=False) if as_json else config
+    outcome = Agent(agent_config, pool).run_turn(session, ReplUI(), threading.Event())
+    session.autosave()  # persist so `scoot -c` can continue this conversation
+
+    if as_json:
+        print(_json.dumps({
+            "status": outcome.status,
+            "model": session.active_model,
+            "steps": outcome.steps,
+            "content": outcome.content,
+            "error": outcome.error,
+            "usage": session.last_usage,
+        }, indent=2))
+        return 0 if outcome.status == "done" else 1
+
+    if outcome.status == "done":
+        if outcome.content.strip() and not outcome.streamed:
+            print(outcome.content.strip())
+        if config.verbose:
+            u = session.last_usage
+            eprint(color(f"[{session.active_model}] steps={outcome.steps} "
+                         f"prompt={u.get('prompt_tokens', '?')} "
+                         f"completion={u.get('completion_tokens', '?')}", "gray"))
+        return 0
+    eprint(color(f"⚠ {redact(outcome.error or outcome.status)}", "red"))
+    return 1
+
+
+def _cmd_auth(config: Config, pool: ProviderPool, words: List[str]) -> int:
+    """``scoot auth [set|clear <provider>]``: the /auth slash-command from the shell."""
+    from . import commands
+    from .repl import ReplSession
+
+    commands.load_builtins()
+    session = ReplSession(config, pool)
+    commands.get("auth").handler(session, " ".join(words))
+    return 0
+
+
+def _interactive(pool: ProviderPool, resume=None) -> int:
+    """Launch the persistent REPL (banner, live status, ESC-interrupt, slash-commands)."""
+    from .auth import is_configured, missing_key_hint
+    from .repl import Repl
+
+    config = pool.config
+    # resume=auto (SCOOT_RESUME / --resume-last): reload the latest session for this directory
+    # unless the user already picked one explicitly via --resume/--continue.
+    if resume is None and getattr(config, "resume", "hint") == "auto":
+        from . import sessions
+
+        resume = sessions.latest_for_root(str(config.root))
+
+    try:
+        spec = pool.spec
+        if not is_configured(spec):  # first-run onboarding: guide, but still open the REPL
+            eprint(color(f"No API key for {spec.name}: {missing_key_hint(spec)}", "yellow"))
+    except ScootError as exc:
+        eprint(color(f"⚠ {redact(str(exc))}", "yellow"))
+    return Repl(config, pool, resume=resume).run()
+
+
+def _resolve_resume(config: Config, args: argparse.Namespace):
+    """Return a SessionRecord to resume (from --resume/--continue), or None. Exits on a bad id."""
+    from . import sessions
+
+    if args.resume:
+        record = sessions.load(args.resume)
+        if record is None:
+            eprint(color(f"no session with id '{args.resume}' (try running /sessions).", "yellow"))
+            raise SystemExit(1)
+        return record
+    if args.continue_latest:
+        record = sessions.latest_for_root(str(config.root))
+        if record is None:
+            eprint(color("no saved session to continue for this directory.", "yellow"))
+            raise SystemExit(1)
+        return record
+    return None
+
+
+def _resolve_prompt(args: argparse.Namespace) -> Optional[str]:
+    """Turn positional args (+ presets) into a task prompt, or None for the REPL."""
+    from . import presets
+
+    words = args.prompt
+    if not words:
+        return None
+    head, rest = words[0], words[1:]
+    if presets.is_preset(head):
+        return presets.build_prompt(head, rest, args.message)
+    return " ".join(words)
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    args = _build_parser().parse_args(argv)
+    try:
+        config = _config_from_args(args)
+        pool = ProviderPool(config)
+
+        if args.prompt and args.prompt[0] == "models":
+            return _cmd_models(pool, args.json, vision_only=args.vision, provider=args.provider)
+
+        if args.prompt and args.prompt[0] == "auth":
+            return _cmd_auth(config, pool, args.prompt[1:])
+
+        prompt = _resolve_prompt(args)
+        resume = _resolve_resume(config, args)
+        if prompt is not None:
+            return _run_once(config, pool, prompt, args.json, resume=resume)
+        return _interactive(pool, resume=resume)
+    except ScootError as exc:
+        eprint(color(f"⚠ {redact(str(exc))}", "red"))
+        return 1
+    except KeyboardInterrupt:
+        print()
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+

scootcli/clipboard.py

@@ -0,0 +1,89 @@
+"""Copy text to the system clipboard using stdlib only (PLAN §3 / M21).
+
+Strategy (first that works wins):
+  1. A platform clipboard binary via ``subprocess`` — ``pbcopy`` (macOS), ``wl-copy`` / ``xclip`` /
+     ``xsel`` (Linux), ``clip.exe`` (WSL/Windows).
+  2. An **OSC 52** terminal escape written to the TTY (``\\033]52;c;<base64>\\a``) — works over SSH with
+     no helper binary, when the terminal supports it.
+
+Everything degrades gracefully: :func:`copy_to_clipboard` returns ``False`` when no path works, so the
+caller can show a friendly note instead of raising.
+"""
+
+from __future__ import annotations
+
+import base64
+import shutil
+import subprocess
+import sys
+
+# (binary name, extra args) in priority order.
+_BINARIES = (
+    ("pbcopy", ()),                              # macOS
+    ("wl-copy", ()),                             # Wayland
+    ("xclip", ("-selection", "clipboard")),      # X11
+    ("xsel", ("--clipboard", "--input")),        # X11
+    ("clip.exe", ()),                            # WSL / Windows
+)
+
+# Many terminals cap the OSC 52 payload; bail on very large content rather than corrupt the clipboard.
+_OSC52_MAX_B64 = 100_000
+
+
+def _via_binary(text: str) -> bool:
+    """Pipe ``text`` into the first available clipboard binary on ``PATH``."""
+    for name, args in _BINARIES:
+        path = shutil.which(name)
+        if not path:
+            continue
+        try:
+            subprocess.run(
+                [path, *args],
+                input=text.encode("utf-8"),
+                check=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            return True
+        except Exception:
+            continue  # try the next backend
+    return False
+
+
+def _via_osc52(text: str) -> bool:
+    """Set the clipboard via an OSC 52 escape (SSH-friendly; needs terminal support)."""
+    if not sys.stdout.isatty():
+        return False
+    try:
+        b64 = base64.b64encode(text.encode("utf-8")).decode("ascii")
+    except Exception:
+        return False
+    if len(b64) > _OSC52_MAX_B64:
+        return False
+    try:
+        sys.stdout.write(f"\033]52;c;{b64}\a")
+        sys.stdout.flush()
+    except Exception:
+        return False
+    return True
+
+
+def copy_to_clipboard(text: str) -> bool:
+    """Copy ``text`` to the clipboard. Returns ``True`` on success, ``False`` if no method worked."""
+    if not text:
+        return False
+    return _via_binary(text) or _via_osc52(text)
+
+
+def copy_session_output(session) -> "tuple[bool, str]":
+    """Copy the session's last assistant answer. Returns ``(ok, human_message)``.
+
+    Shared by the ``/c`` slash-command and the in-editor Ctrl-S hotkey so both behave identically.
+    """
+    text = (getattr(session, "last_output", "") or "").strip()
+    if not text:
+        return False, "nothing to copy yet — ask me something first."
+    if copy_to_clipboard(text):
+        return True, f"copied last answer ({len(text)} chars) to the clipboard."
+    return False, "couldn't reach a clipboard (no pbcopy/xclip/OSC-52 support)."
+

scootcli/commands/__init__.py

@@ -0,0 +1,56 @@
+"""Slash-command registry. Drop a new module in this package and call :func:`register` to add one."""
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+
+from .base import QUIT, SlashCommand
+
+__all__ = ["QUIT", "SlashCommand", "register", "get", "all_commands", "load_builtins"]
+
+_REGISTRY: Dict[str, SlashCommand] = {}
+
+
+def register(command: SlashCommand) -> None:
+    _REGISTRY[command.name] = command
+
+
+def get(name: str) -> Optional[SlashCommand]:
+    return _REGISTRY.get(name)
+
+
+def all_commands() -> Dict[str, SlashCommand]:
+    return dict(sorted(_REGISTRY.items()))
+
+
+_loaded = False
+
+
+def load_builtins() -> None:
+    """Import the built-in command modules so they self-register (idempotent)."""
+    global _loaded
+    if _loaded:
+        return
+    # Importing each module triggers its register() call.
+    from . import help as _help  # noqa: F401
+    from . import exit as _exit  # noqa: F401
+    from . import reset as _reset  # noqa: F401
+    from . import save as _save  # noqa: F401
+    from . import status as _status  # noqa: F401
+    from . import model as _model  # noqa: F401
+    from . import init as _init  # noqa: F401
+    from . import compact as _compact  # noqa: F401
+    from . import approve as _approve  # noqa: F401
+    from . import yolo as _yolo  # noqa: F401
+    from . import worktree as _worktree  # noqa: F401
+    from . import auth as _auth  # noqa: F401
+    from . import sessions as _sessions  # noqa: F401
+    from . import resume as _resume  # noqa: F401
+    from . import forget as _forget  # noqa: F401
+    from . import panel as _panel  # noqa: F401
+    from . import verbosity as _verbosity  # noqa: F401
+    from . import copy as _copy  # noqa: F401
+    from . import logo as _logo  # noqa: F401
+
+    _loaded = True
+

scootcli/commands/approve.py

@@ -0,0 +1,38 @@
+"""/approve — view or set the session approval mode (always | auto-read | auto-edits | yolo)."""
+
+from __future__ import annotations
+
+from ..approvals import MODES
+from ..rendering import color
+from . import register
+from .base import SlashCommand
+
+_DESCRIPTIONS = {
+    "always": "prompt for every tool call (safest)",
+    "auto-read": "auto-approve read-only tools; prompt writes & shell",
+    "auto-edits": "auto-approve reads & file edits; prompt shell only",
+    "yolo": "auto-approve everything (denylisted shell commands still confirmed)",
+}
+
+
+def _run(session, args: str):
+    arg = args.strip().lower()
+    if not arg:
+        print(color(f"approval mode: {session.approval_mode}", "bold"))
+        for mode in MODES:
+            mark = color(" ← current", "green") if mode == session.approval_mode else ""
+            print(f"  {color(mode, 'cyan')}{mark}  {color('— ' + _DESCRIPTIONS[mode], 'gray')}")
+        print(color("  use: /approve <mode>   (or /yolo)", "gray"))
+        return
+    if arg not in MODES:
+        print(color(f"unknown mode '{arg}'. choose: {', '.join(MODES)}", "yellow"))
+        return
+    session.approval_mode = arg
+    print(color(f"approval mode set to {arg}.", "gray"))
+    if arg == "yolo":
+        print(color("  ⚠ yolo: tool calls run without asking (destructive shell commands still confirmed).", "yellow"))
+
+
+register(SlashCommand("approve", "view/set approval mode", _run,
+                      usage="[always|auto-read|auto-edits|yolo]"))
+

scootcli/commands/auth.py

@@ -0,0 +1,107 @@
+"""/auth — show which providers have an API key, or save / forget one.
+
+  /auth                 table of providers: key source, default marker, base URL
+  /auth set <provider>  paste a key (hidden input), validate it against the provider, save it
+  /auth clear <provider>  forget the saved key (an environment key is not ours to remove)
+"""
+
+from __future__ import annotations
+
+import getpass
+
+from ..activity import activity
+from ..auth import key_source, missing_key_hint, status_rows
+from ..credentials import credentials_path, delete_key, save_key
+from ..errors import ScootError
+from ..providers import registry
+from ..rendering import color, eprint, redact
+from . import register
+from .base import SlashCommand
+
+
+def _show(session) -> None:
+    rows = status_rows(session.config)
+    print(color("providers:", "bold"))
+    for row in rows:
+        name = row["name"] + ("  (default)" if row["default"] else "")
+        if not row["required"]:
+            state = color("no key needed", "gray")
+        elif row["source"]:
+            state = color(f"key from {row['source']}", "green")
+        else:
+            state = color("no key", "yellow")
+        print(f"  {color(name, 'cyan'):<32} {state}  {color(row['base_url'], 'gray')}")
+    print(color("  usage: /auth set <provider> · /auth clear <provider>", "gray"))
+    print(color(f"  saved keys live in {credentials_path()} (owner-only)", "gray"))
+
+
+def _set(session, name: str) -> None:
+    spec = registry.get(name)
+    if spec is None:
+        eprint(color(f"unknown provider '{name}'. known: {', '.join(registry.names())}", "yellow"))
+        return
+    if not spec.key_required:
+        print(color(f"{name} needs no API key.", "gray"))
+        return
+    print(color(f"paste the {name} API key; it is validated before being saved and never echoed.", "gray"))
+    try:
+        key = getpass.getpass(f"{name} API key (hidden, blank to cancel): ").strip()
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return
+    if not key:
+        print(color("no key entered; nothing changed.", "gray"))
+        return
+    probe = registry.make_provider(name, session.config)
+    probe._api_key = key
+    try:
+        with activity(f"checking {name} key…") as cancel:
+            probe.list_models(cancel_event=cancel)
+    except ScootError as exc:
+        eprint(color(f"✗ key rejected: {redact(str(exc))}", "red"))
+        if getattr(exc, "hint", ""):
+            print(color(f"  {exc.hint}", "gray"))
+        return
+    path = save_key(name, key)
+    pool = getattr(session, "provider", None)
+    if pool is not None and hasattr(pool, "_providers"):
+        pool._providers.pop(name, None)  # rebuild with the new key on next use
+    print(color(f"✔ {name} key saved to {path} (owner-only).", "green"))
+
+
+def _clear(session, name: str) -> None:
+    spec = registry.get(name)
+    if spec is None:
+        eprint(color(f"unknown provider '{name}'. known: {', '.join(registry.names())}", "yellow"))
+        return
+    if delete_key(name):
+        print(color(f"forgot the saved {name} key.", "green"))
+    else:
+        print(color(f"no saved {name} key.", "gray"))
+    pool = getattr(session, "provider", None)
+    if pool is not None and hasattr(pool, "_providers"):
+        pool._providers.pop(name, None)
+    src = key_source(spec)
+    if src:
+        print(color(f"  note: {name} still has a key from {src} (not managed by scoot).", "gray"))
+    elif spec.key_required:
+        print(color(f"  {missing_key_hint(spec)}", "gray"))
+
+
+def _run(session, args: str):
+    words = (args or "").split()
+    if not words:
+        _show(session)
+        return
+    action, name = words[0].lower(), (words[1].lower() if len(words) > 1 else "")
+    if action in ("set", "add", "login") and name:
+        _set(session, name)
+    elif action in ("clear", "remove", "forget", "logout") and name:
+        _clear(session, name)
+    elif action == "status":
+        _show(session)
+    else:
+        eprint(color("usage: /auth [set <provider> | clear <provider>]", "yellow"))
+
+
+register(SlashCommand("auth", "show provider keys, or set/clear one", _run, usage="[set|clear <provider>]"))

scootcli/commands/base.py

@@ -0,0 +1,31 @@
+"""SlashCommand interface for the drop-in command registry (PLAN §6, §2 design principles).
+
+Adding a new slash-command = drop a module in this package that builds a :class:`SlashCommand` and
+calls :func:`scootcli.commands.register`. No core edits required.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Callable, Optional
+
+if TYPE_CHECKING:  # avoid a circular import at runtime
+    from ..repl import ReplSession
+
+# Control-flow signal a command may return to the REPL.
+QUIT = "quit"
+
+
+@dataclass
+class SlashCommand:
+    """A REPL slash-command.
+
+    ``handler(session, args)`` runs the command. It may return :data:`QUIT` to end the session,
+    otherwise ``None``. ``args`` is the raw text after the command name.
+    """
+
+    name: str
+    summary: str
+    handler: "Callable[[ReplSession, str], Optional[str]]"
+    usage: str = ""
+

scootcli/commands/compact.py

@@ -0,0 +1,40 @@
+"""/compact — summarize the conversation, clear it, and continue from the summary."""
+
+from __future__ import annotations
+
+from ..activity import activity
+from ..context import compact, estimate_context_tokens, estimate_messages_tokens
+from ..errors import ScootError, Interrupted
+from ..rendering import color, eprint
+from . import register
+from .base import SlashCommand
+
+
+def _run(session, args: str):
+    if not session.messages:
+        print(color("nothing to compact.", "gray"))
+        return
+    before = estimate_context_tokens(session)
+    try:
+        with activity("compacting context…") as cancel:
+            summary = compact(session, cancel)
+    except Interrupted:
+        print(color("⏹ interrupted", "yellow"))
+        return
+    except ScootError as exc:
+        eprint(color(f"compact failed: {exc}", "red"))
+        return
+    if not summary:
+        print(color("nothing to compact.", "gray"))
+        return
+    after = estimate_messages_tokens(session.messages)
+    note = f"context compacted: ~{before} → ~{after} prompt tokens. Continuing from summary."
+    redraw = getattr(session, "redraw_home", None)
+    if callable(redraw):
+        redraw(note)
+    else:
+        print(color(note, "gray"))
+
+
+register(SlashCommand("compact", "summarize & shrink the conversation", _run))
+

scootcli/commands/copy.py

@@ -0,0 +1,23 @@
+"""/c — copy the most recent assistant answer to the system clipboard (PLAN §3 / M21).
+
+The same action is available in the input dock via Ctrl-S. ⌘C can't be used: terminal emulators keep
+the ⌘ (Super) modifier for themselves and never forward it to the program.
+"""
+
+from __future__ import annotations
+
+from ..clipboard import copy_session_output
+from ..rendering import color, eprint
+from . import register
+from .base import SlashCommand
+
+
+def _run(session, args: str):
+    ok, message = copy_session_output(session)
+    (print if ok else eprint)(color(message, "gray" if ok else "yellow"))
+
+
+register(SlashCommand("c", "copy the last answer to the clipboard (also Ctrl-S)", _run))
+# Discoverable alias for people who reach for the long form.
+register(SlashCommand("copy", "copy the last answer to the clipboard (alias of /c)", _run))
+

scootcli/commands/exit.py

@@ -0,0 +1,14 @@
+"""/exit — quit the REPL."""
+
+from __future__ import annotations
+
+from . import QUIT, register
+from .base import SlashCommand
+
+
+def _run(session, args: str):
+    return QUIT
+
+
+register(SlashCommand("exit", "quit scoot", _run))
+