scootcli 0.8.0__tar.gz → 0.8.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scootcli
-Version: 0.8.0
+Version: 0.8.1
 Summary: A tiny coding agent that goes where you point it
 Author: Sergey Nes
 License-Expression: MIT
@@ -115,8 +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.
-Starting the REPL with `--model` is remembered the same way, so `scoot --model ollama/llama3.2` once and plain `scoot` afterwards keep using it; a one-shot `scoot --model X "prompt"` does not change the saved choice.
+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
 
@@ -171,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` |

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

@@ -90,8 +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.
-Starting the REPL with `--model` is remembered the same way, so `scoot --model ollama/llama3.2` once and plain `scoot` afterwards keep using it; a one-shot `scoot --model X "prompt"` does not change the saved choice.
+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
 
@@ -146,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` |

{scootcli-0.8.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.8.0"
+__version__ = "0.8.1"
 

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

@@ -229,9 +229,9 @@ def _interactive(pool: ProviderPool, resume=None, remember_model: Optional[str]
     """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, exactly like ``/model`` inside the REPL, so it is saved as the
-    preference and a plain ``scoot`` 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.
+    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
 
@@ -239,7 +239,7 @@ def _interactive(pool: ProviderPool, resume=None, remember_model: Optional[str]
     if remember_model and remember_model.strip():
         from .preferences import set_model
 
-        set_model(remember_model.strip())
+        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":

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.8.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.8.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.8.1/src/scootcli/preferences.py

@@ -0,0 +1,144 @@
+"""Persisted user preferences (the chosen model, the mascot toggle), surviving across launches.
+
+One file at ``~/.config/scoot/preferences.json`` (``SCOOT_CONFIG_DIR`` overrides the location, used by
+tests). The model preference has two layers: ``models`` maps a workspace root to the model chosen
+there (``/model`` or ``--model`` in that folder), and ``model`` is the choice for every folder without
+one (``/model X everywhere``). Writing is best-effort: a failure never breaks the CLI.
+"""
+
+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 ────────────────────────────────────────────────────────────
+FOLDER = "folder"        # the model saved for this workspace root
+EVERYWHERE = "everywhere"  # the model saved for every folder without its own
+
+
+def _root_key(root) -> str:
+    return str(Path(root).expanduser().resolve())
+
+
+def _folder_models(prefs: dict) -> dict:
+    models = prefs.get("models")
+    return models if isinstance(models, dict) else {}
+
+
+def saved_models(root=None):
+    """``(folder_model, global_model)``: what is saved for ``root`` (``None`` without a root) and for
+    everywhere; either may be ``None``."""
+    prefs = load_preferences()
+    folder = _folder_models(prefs).get(_root_key(root)) if root is not None else None
+    return (folder or None), (prefs.get("model") or None)
+
+
+def get_model(root=None) -> Optional[str]:
+    """The saved model that applies in ``root``: the folder's own choice, else the global one."""
+    folder, everywhere = saved_models(root)
+    return folder or everywhere
+
+
+def model_source(root=None) -> Optional[str]:
+    """Which layer :func:`get_model` answered from: ``"folder"``, ``"everywhere"``, or ``None``."""
+    folder, everywhere = saved_models(root)
+    return FOLDER if folder else (EVERYWHERE if everywhere else None)
+
+
+def set_model(name: str, root=None) -> None:
+    """Persist the chosen model (including ``auto`` / ``default``) so the next launch reuses it: for
+    the folder ``root`` when given, otherwise for every folder (which also drops the folder's own
+    entry when ``root`` is passed as ``everywhere=True`` via :func:`set_model_everywhere`)."""
+    if root is None:
+        save_preference("model", name)
+        return
+    prefs = load_preferences()
+    models = dict(_folder_models(prefs))
+    models[_root_key(root)] = name
+    prefs["models"] = models
+    _write(prefs)
+
+
+def set_model_everywhere(name: str, root=None) -> None:
+    """Make ``name`` the model for every folder, and forget ``root``'s own choice so it applies there too."""
+    prefs = load_preferences()
+    prefs["model"] = name
+    if root is not None:
+        models = dict(_folder_models(prefs))
+        models.pop(_root_key(root), None)
+        prefs["models"] = models
+    _write(prefs)
+
+
+def clear_model(root=None) -> None:
+    """Forget the saved model: the folder's own entry when ``root`` is given, else the global one."""
+    if root is None:
+        save_preference("model", None)
+        return
+    prefs = load_preferences()
+    models = dict(_folder_models(prefs))
+    if models.pop(_root_key(root), None) is not None:
+        prefs["models"] = models
+        _write(prefs)
+
+
+# ── 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-0.8.0 → scootcli-0.8.1/src/scootcli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scootcli
-Version: 0.8.0
+Version: 0.8.1
 Summary: A tiny coding agent that goes where you point it
 Author: Sergey Nes
 License-Expression: MIT
@@ -115,8 +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.
-Starting the REPL with `--model` is remembered the same way, so `scoot --model ollama/llama3.2` once and plain `scoot` afterwards keep using it; a one-shot `scoot --model X "prompt"` does not change the saved choice.
+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
 
@@ -171,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` |