scootcli 0.7.0__tar.gz → 0.8.1__tar.gz

{scootcli-0.7.0/src/scootcli.egg-info → scootcli-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scootcli
-Version: 0.7.0
+Version: 0.8.1
 Summary: A tiny coding agent that goes where you point it
 Author: Sergey Nes
 License-Expression: MIT
@@ -115,7 +115,9 @@ scoot --model openai/gpt-5.3-codex "..."
 scoot --model auto "..."             # pick a model per prompt from the live list (cheap for trivial, strong for edits)
 ```
 
-Inside the REPL, `/model <provider/model>` switches and is remembered for the next launch; `/model default` goes back to the provider's preferred model.
+Inside the REPL, `/model <provider/model>` switches and is remembered for the folder you are in, so each project can have its own model; `/model default` goes back to the provider's preferred model.
+Starting the REPL with `--model` is remembered the same way, so `scoot --model ollama/llama3.2` once and plain `scoot` afterwards keep using it there; a one-shot `scoot --model X "prompt"` does not change the saved choice.
+`/model X everywhere` makes `X` the model for every folder that has no choice of its own, `/model forget` drops the current folder's choice so it follows that, and `/status` says where the active model came from.
 
 ### Routing
 
@@ -170,7 +172,7 @@ The most useful settings (see [`.env.example`](./.env.example) for all of them):
 |---|---|---|
 | `OPENAI_API_KEY` | OpenAI key (or `scoot auth set openai`) | |
 | `SCOOT_PROVIDER` | default provider for bare model names | first with a key, else `ollama` |
-| `SCOOT_MODEL` | `default`, `auto`, or `provider/model` | `default` |
+| `SCOOT_MODEL` | `default`, `auto`, or `provider/model`; overrides the saved per-folder and global choices | `default` |
 | `SCOOT_EFFORT` | reasoning effort | `medium` |
 | `SCOOT_APPROVAL` | `always` · `auto-read` · `auto-edits` · `yolo` | `yolo` |
 | `SCOOT_MAX_STEPS` | tool-call steps per turn before asking to continue | `50` |
@@ -219,6 +221,7 @@ Press **Ctrl-N** while a turn is running to add a note: scoot asks for one line
 Type `/` and press **Tab** to complete slash commands.
 
 **Terminals.** scoot works in macOS Terminal, iTerm2, and inside tmux; the status bar uses a scroll region, the input dock uses raw mode, and clipboard copy uses the system tool or an OSC-52 escape.
+Resizing the window or zooming the font (also under tmux) repaints the dock at once: the transcript stays where it was, the input keeps its place and the bar is redrawn, at the prompt and while a turn runs.
 Under tmux, ESC reaches scoot only after tmux's `escape-time` has passed, so with the default 500 ms the interrupt feels delayed; `set -sg escape-time 10` in `~/.tmux.conf` makes it immediate.
 For clipboard copy through tmux, `set -g set-clipboard on` (or `external`) lets the OSC-52 escape reach the outer terminal.
 Without a TTY, scoot falls back to a plain prompt with no bar and no dock.

{scootcli-0.7.0 → scootcli-0.8.1}/README.md

@@ -90,7 +90,9 @@ scoot --model openai/gpt-5.3-codex "..."
 scoot --model auto "..."             # pick a model per prompt from the live list (cheap for trivial, strong for edits)
 ```
 
-Inside the REPL, `/model <provider/model>` switches and is remembered for the next launch; `/model default` goes back to the provider's preferred model.
+Inside the REPL, `/model <provider/model>` switches and is remembered for the folder you are in, so each project can have its own model; `/model default` goes back to the provider's preferred model.
+Starting the REPL with `--model` is remembered the same way, so `scoot --model ollama/llama3.2` once and plain `scoot` afterwards keep using it there; a one-shot `scoot --model X "prompt"` does not change the saved choice.
+`/model X everywhere` makes `X` the model for every folder that has no choice of its own, `/model forget` drops the current folder's choice so it follows that, and `/status` says where the active model came from.
 
 ### Routing
 
@@ -145,7 +147,7 @@ The most useful settings (see [`.env.example`](./.env.example) for all of them):
 |---|---|---|
 | `OPENAI_API_KEY` | OpenAI key (or `scoot auth set openai`) | |
 | `SCOOT_PROVIDER` | default provider for bare model names | first with a key, else `ollama` |
-| `SCOOT_MODEL` | `default`, `auto`, or `provider/model` | `default` |
+| `SCOOT_MODEL` | `default`, `auto`, or `provider/model`; overrides the saved per-folder and global choices | `default` |
 | `SCOOT_EFFORT` | reasoning effort | `medium` |
 | `SCOOT_APPROVAL` | `always` · `auto-read` · `auto-edits` · `yolo` | `yolo` |
 | `SCOOT_MAX_STEPS` | tool-call steps per turn before asking to continue | `50` |
@@ -194,6 +196,7 @@ Press **Ctrl-N** while a turn is running to add a note: scoot asks for one line
 Type `/` and press **Tab** to complete slash commands.
 
 **Terminals.** scoot works in macOS Terminal, iTerm2, and inside tmux; the status bar uses a scroll region, the input dock uses raw mode, and clipboard copy uses the system tool or an OSC-52 escape.
+Resizing the window or zooming the font (also under tmux) repaints the dock at once: the transcript stays where it was, the input keeps its place and the bar is redrawn, at the prompt and while a turn runs.
 Under tmux, ESC reaches scoot only after tmux's `escape-time` has passed, so with the default 500 ms the interrupt feels delayed; `set -sg escape-time 10` in `~/.tmux.conf` makes it immediate.
 For clipboard copy through tmux, `set -g set-clipboard on` (or `external`) lets the OSC-52 escape reach the outer terminal.
 Without a TTY, scoot falls back to a plain prompt with no bar and no dock.

{scootcli-0.7.0 → scootcli-0.8.1}/src/scootcli/__init__.py

@@ -1,4 +1,4 @@
 """scoot: a tiny coding agent that goes where you point it."""
 
-__version__ = "0.7.0"
+__version__ = "0.8.1"
 

{scootcli-0.7.0 → scootcli-0.8.1}/src/scootcli/cli.py

@@ -225,11 +225,21 @@ def _cmd_auth(config: Config, pool: ProviderPool, words: List[str]) -> int:
     return 0
 
 
-def _interactive(pool: ProviderPool, resume=None) -> int:
-    """Launch the persistent REPL (banner, live status, ESC-interrupt, slash-commands)."""
+def _interactive(pool: ProviderPool, resume=None, remember_model: Optional[str] = None) -> int:
+    """Launch the persistent REPL (banner, live status, ESC-interrupt, slash-commands).
+
+    ``remember_model`` is the model named on the command line (``--model``), if any. Launching the REPL
+    with it counts as choosing it for this folder, exactly like ``/model`` inside the REPL, so a plain
+    ``scoot`` here next time starts on the same model. One-shot prompts and headless runs do not save
+    it: a flag on a single command is not a choice for the next session.
+    """
     from .repl import Repl
 
     config = pool.config
+    if remember_model and remember_model.strip():
+        from .preferences import set_model
+
+        set_model(remember_model.strip(), root=config.root)
     # 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":
@@ -309,7 +319,7 @@ def main(argv: Optional[List[str]] = None) -> int:
             return run_headless(config.override(panel=False, dock=False, logo=False), pool, resume=resume)
         if prompt is not None:
             return _run_once(config, pool, prompt, args.json, resume=resume)
-        return _interactive(pool, resume=resume)
+        return _interactive(pool, resume=resume, remember_model=args.model)
     except ScootError as exc:
         eprint(color(f"⚠ {redact(str(exc))}", "red"))
         return 1

scootcli-0.8.1/src/scootcli/commands/model.py

@@ -0,0 +1,115 @@
+"""/model: list available models or switch the active one.
+
+Models are ``provider/model`` ids (``openai/gpt-5.3-codex``, ``ollama/llama3.2``); a bare name means
+the default provider. A switch made here is **persisted** (``~/.config/scoot/preferences.json``) for
+this folder, so the next launch here reuses it; ``/model X everywhere`` saves it for every folder
+without a choice of its own, and ``/model forget`` drops this folder's choice so it follows that. An
+explicit ``--model`` flag or ``SCOOT_MODEL`` still overrides it for that run.
+"""
+
+from __future__ import annotations
+
+from .. import preferences
+from ..providers.base import qualify, split_model_id
+from ..rendering import color
+from . import register
+from .base import SlashCommand
+
+_USAGE = "/model <provider/model> · /model default · /model auto (pick per task) · add 'everywhere' for all folders · /model forget"
+
+
+def _root(session):
+    return getattr(getattr(session, "config", None), "root", None)
+
+
+def _saved_line(session) -> str:
+    folder, everywhere = preferences.saved_models(_root(session))
+    return f"saved: this folder {folder or '(none)'} · everywhere {everywhere or '(none)'}"
+
+
+def _remember(session, name: str, everywhere: bool) -> str:
+    """Persist ``name`` for this folder (or every folder); return how to say so."""
+    root = _root(session)
+    if everywhere:
+        preferences.set_model_everywhere(name, root=root)
+        _note_origin(session, name, preferences.EVERYWHERE)
+        return "saved for every folder"
+    preferences.set_model(name, root=root)
+    _note_origin(session, name, preferences.FOLDER)
+    return "saved for this folder"
+
+
+def _note_origin(session, name: str, source: str) -> None:
+    """Keep ``config.model_source`` truthful after a switch, so ``/status`` names the right layer."""
+    cfg = getattr(session, "config", None)
+    if cfg is not None and hasattr(cfg, "override"):
+        session.config = cfg.override(model=name, model_source=source)
+
+
+def _run(session, args: str):
+    words = args.split()
+    everywhere = False
+    if words and words[-1].lower() == "everywhere":
+        everywhere = True
+        words = words[:-1]
+    arg = " ".join(words)
+    available = session.available_models()
+
+    if not arg:
+        print(color(f"models  (preference: {session.model} → active: {session.active_model})", "bold"))
+        print(color(f"  {_saved_line(session)}", "gray"))
+        current = ""
+        for mid in available:
+            head, _ = split_model_id(mid)
+            if head != current:
+                current = head
+                print(color(f"  {head}", "bold"))
+            mark = color(" ← active", "green") if mid == session.active_model else ""
+            print("    " + color(mid, "cyan") + mark)
+        errors = getattr(getattr(session, "provider", None), "list_errors", None) or {}
+        for name, err in sorted(errors.items()):
+            print(color(f"  {name}: unavailable ({err})", "yellow"))
+        print(color(f"  use: {_USAGE}", "gray"))
+        return
+
+    if arg == "forget":
+        preferences.clear_model(root=_root(session))
+        session.model = preferences.get_model(_root(session)) or "default"
+        session.active_model = session.resolved_model()
+        _note_origin(session, session.model, preferences.model_source(_root(session)) or "default")
+        print(color(f"this folder's model choice forgotten; now {session.model} → {session.active_model}. "
+                    f"{_saved_line(session)}", "gray"))
+        if hasattr(session, "refresh_readiness") and not session.refresh_readiness():
+            print(color(session.setup_message, "yellow"))
+        return
+
+    if arg in ("auto", "default"):
+        session.model = arg
+        session.active_model = session.resolved_model()
+        how = _remember(session, arg, everywhere)
+        what = "picked per task from the live list" if arg == "auto" else f"the provider's preferred model, now {session.active_model}"
+        print(color(f"model preference set to {arg} ({what}); {how}.", "gray"))
+        if hasattr(session, "refresh_readiness") and not session.refresh_readiness():
+            print(color(session.setup_message, "yellow"))
+        return
+
+    if arg not in available:
+        head, _ = split_model_id(arg)
+        if head is None:
+            try:
+                arg = qualify(session.provider.default_name, arg)
+            except Exception:
+                pass
+        if arg not in available:
+            print(color(f"warning: '{arg}' is not in the models list; setting it anyway.", "yellow"))
+    session.model = arg
+    session.active_model = arg
+    how = _remember(session, arg, everywhere)
+    print(color(f"model set to {arg}; {how}.", "gray"))
+    if hasattr(session, "refresh_readiness") and not session.refresh_readiness():
+        print(color(session.setup_message, "yellow"))
+
+
+register(SlashCommand("model", "list or switch model (default|auto|provider/model), per folder or everywhere",
+                      _run, usage="[provider/model|default|auto] [everywhere] | forget"))
+

{scootcli-0.7.0 → scootcli-0.8.1}/src/scootcli/commands/status.py

@@ -7,6 +7,16 @@ from . import register
 from .base import SlashCommand
 
 
+_ORIGINS = {"flag": "--model", "env": "SCOOT_MODEL", "folder": "saved for this folder",
+            "everywhere": "saved for every folder", "default": "the default"}
+
+
+def _model_origin(session) -> str:
+    """``"  (from --model)"`` and the like: which layer chose the model this run started with."""
+    src = getattr(getattr(session, "config", None), "model_source", "")
+    return f"  (from {_ORIGINS[src]})" if src in _ORIGINS else ""
+
+
 def _run(session, args: str):
     cfg = session.config
     try:
@@ -20,7 +30,8 @@ def _run(session, args: str):
         provider_row = getattr(cfg, "provider", "") or "?"
     rows = [
         ("provider", provider_row),
-        ("model", session.active_model + ("  (auto)" if session.model.lower() == "auto" else "")),
+        ("model", session.active_model + ("  (auto)" if session.model.lower() == "auto" else "")
+         + _model_origin(session)),
         ("effort", getattr(cfg, "effort", "medium")),
         ("env files", ", ".join(getattr(cfg, "env_files", ()) or ()) or "none"),
         ("update", (f"{session.update_available} available: pipx upgrade scootcli"

{scootcli-0.7.0 → scootcli-0.8.1}/src/scootcli/config.py

@@ -2,6 +2,9 @@
 
 Precedence (highest wins):
   CLI flag → environment variable → project ``.env`` → global ``~/.config/scoot/.env`` → default.
+The model has two more layers between the ``.env`` files and the default: the model saved for this
+workspace root, then the one saved for every folder (see ``preferences.py``); ``model_source`` says
+which layer answered.
 
 Two optional ``.env`` files are read: the global one in scoot's config home, and the nearest ``.env``
 found walking up from the current directory (so a repo-root file applies from any subdirectory).
@@ -129,16 +132,23 @@ def is_model_alias(model: Optional[str]) -> bool:
     return (model or "").strip().lower() in (DEFAULT_MODEL_ALIAS, AUTO_MODEL_ALIAS, "")
 
 
-def _resolve_model_setting(model_env: Optional[str]) -> str:
-    """Model precedence (below the CLI flag, applied later): SCOOT_MODEL → saved pref → default."""
+MODEL_SOURCES = ("flag", "env", "folder", "everywhere", "default")
+
+
+def _resolve_model_setting(model_env: Optional[str], root=None) -> Tuple[str, str]:
+    """``(model, source)`` below the CLI flag (applied later): SCOOT_MODEL → the model saved for
+    ``root`` → the model saved for every folder → default."""
     if model_env:
-        return model_env
+        return model_env, "env"
     try:
-        from .preferences import get_model
+        from .preferences import get_model, model_source
 
-        return get_model() or DEFAULT_MODEL_ALIAS
+        saved = get_model(root)
+        if saved:
+            return saved, model_source(root) or "everywhere"
     except Exception:
-        return DEFAULT_MODEL_ALIAS
+        pass
+    return DEFAULT_MODEL_ALIAS, "default"
 
 
 def _resolve_logo_setting(logo_env: Optional[str]) -> bool:
@@ -161,6 +171,7 @@ class Config:
     proxy: str = DEFAULT_PROXY
     provider: str = ""  # default provider name; empty → first provider with a key, else ollama
     model: str = DEFAULT_MODEL_ALIAS  # "default" | "auto" | a model id, ideally provider/model
+    model_source: str = "default"  # where ``model`` came from: flag | env | folder | everywhere | default
     effort: str = "medium"  # reasoning effort for models that take it: low | medium | high | xhigh
     timeout: int = 120
     max_steps: int = 50
@@ -194,17 +205,20 @@ class Config:
             load_dotenv(env_file)
 
         get = os.environ.get
+        root = Path(get("SCOOT_ROOT", str(cwd))).resolve()
+        model, model_source = _resolve_model_setting(get("SCOOT_MODEL"), root)
         return cls(
             proxy=get("HTTPS_PROXY") or get("https_proxy") or DEFAULT_PROXY,
             env_files=tuple(str(f) for f in files),
             provider=get("SCOOT_PROVIDER", "").strip().lower(),
-            model=_resolve_model_setting(get("SCOOT_MODEL")),
+            model=model,
+            model_source=model_source,
             effort=get("SCOOT_EFFORT", "medium").strip().lower(),
             timeout=int(get("SCOOT_TIMEOUT", "120")),
             max_steps=int(get("SCOOT_MAX_STEPS", "50")),
             compact_at=int(get("SCOOT_COMPACT_AT", "100000")),
             approval=get("SCOOT_APPROVAL", "yolo"),
-            root=Path(get("SCOOT_ROOT", str(cwd))).resolve(),
+            root=root,
             verbose=_as_bool(get("SCOOT_VERBOSE", "false")),
             stream=_as_bool(get("SCOOT_STREAM", "true")),
             panel=_as_bool(get("SCOOT_PANEL", "true")),
@@ -223,10 +237,18 @@ class Config:
         )
 
     def override(self, **kwargs) -> "Config":
-        """Return a copy with the given (non-None) fields overridden — the CLI-flag layer."""
+        """Return a copy with the given (non-None) fields overridden: the CLI-flag layer.
+
+        A ``model`` here is the flag. A new ``root`` (``--root``) without one re-resolves the saved
+        model for that folder, unless the flag or ``SCOOT_MODEL`` already decided it.
+        """
         clean = {k: v for k, v in kwargs.items() if v is not None}
         if "root" in clean:
             clean["root"] = Path(clean["root"]).resolve()
+        if "model" in clean:
+            clean.setdefault("model_source", "flag")
+        elif "root" in clean and self.model_source not in ("flag", "env") and clean["root"] != self.root:
+            clean["model"], clean["model_source"] = _resolve_model_setting(None, clean["root"])
         return replace(self, **clean)
 
     def resolve_model(self, task_hint: str = "") -> str:

{scootcli-0.7.0 → scootcli-0.8.1}/src/scootcli/keys.py

@@ -6,13 +6,19 @@ the in-flight request (and, later, tool) immediately.
 
 Line editing for typing prompts happens in normal cooked mode (plain ``input()``); raw mode is only
 active *while the agent works*, so we never interfere with the user typing.
+
+While a section is active it is the only reader of stdin, so it also relays the terminal's answer to
+a cursor-position request (``ESC[6n`` → ``ESC[row;colR``); :func:`query_cursor` is how the REPL finds
+out where output is after a resize that happened mid-turn.
 """
 
 from __future__ import annotations
 
 import os
+import re
 import sys
 import threading
+from typing import Optional, Tuple
 
 try:
     import termios
@@ -25,6 +31,35 @@ except ImportError:  # pragma: no cover - non-POSIX
 
 ESC = "\x1b"
 NOTE_KEY = b"\x0e"  # Ctrl-N: ask for a note at the next model call
+_CURSOR_REPORT = re.compile(rb"\x1b\[(\d+);(\d+)R")  # the terminal's answer to ESC[6n
+
+_active_section: "Optional[InterruptibleSection]" = None  # the section currently reading stdin
+
+
+def parse_cursor_report(data: bytes) -> Optional[Tuple[int, int]]:
+    """``(row, col)`` from a byte stream holding ``ESC[row;colR``, or ``None``."""
+    m = _CURSOR_REPORT.search(data)
+    return (int(m.group(1)), int(m.group(2))) if m else None
+
+
+def query_cursor(timeout: float = 0.2) -> Optional[Tuple[int, int]]:
+    """Ask the terminal where the cursor is, while a section's listener can read the answer.
+
+    Returns ``(row, col)`` (1-based) or ``None`` when no section is active (so nothing would read the
+    reply and it would leak into the next prompt) or the terminal did not answer in time.
+    """
+    section = _active_section
+    if section is None or not section.enabled:
+        return None
+    from .resize import CURSOR_REPORT
+
+    section.cursor_event.clear()
+    section.cursor_report = None
+    sys.stdout.write(CURSOR_REPORT)
+    sys.stdout.flush()
+    if section.cursor_event.wait(timeout):
+        return section.cursor_report
+    return None
 
 
 def read_key() -> str:
@@ -63,8 +98,11 @@ class InterruptibleSection:
         self._old_attrs = None
         self._thread = None
         self._stop = threading.Event()
+        self.cursor_report: Optional[Tuple[int, int]] = None  # last ESC[row;colR seen (see query_cursor)
+        self.cursor_event = threading.Event()
 
     def __enter__(self) -> "InterruptibleSection":
+        global _active_section
         if not self.enabled:
             return self
         try:
@@ -76,6 +114,7 @@ class InterruptibleSection:
             return self
         self._thread = threading.Thread(target=self._listen, daemon=True)
         self._thread.start()
+        _active_section = self
         return self
 
     def _listen(self) -> None:
@@ -102,17 +141,27 @@ class InterruptibleSection:
                 except (OSError, ValueError):
                     more = None
                 if more:
+                    seq = bytearray(ch)
                     try:
                         while select.select([sys.stdin], [], [], 0)[0]:
-                            if not os.read(self._fd, 1):
+                            byte = os.read(self._fd, 1)
+                            if not byte:
                                 break
+                            seq += byte
                     except (OSError, ValueError):
                         pass
+                    report = parse_cursor_report(bytes(seq))
+                    if report is not None:  # the terminal answering query_cursor
+                        self.cursor_report = report
+                        self.cursor_event.set()
                     continue
                 self.cancel_event.set()
                 break
 
     def __exit__(self, *exc) -> None:
+        global _active_section
+        if _active_section is self:
+            _active_section = None
         self._stop.set()
         if self._thread is not None:
             self._thread.join(timeout=0.3)