scootcli 0.1.0__py3-none-any.whl

scootcli/commands/forget.py

@@ -0,0 +1,28 @@
+"""/forget [<id>|all] — delete saved session(s) for this workspace root."""
+
+from __future__ import annotations
+
+from ..rendering import color, eprint
+from . import register
+from .base import SlashCommand
+
+
+def _run(session, args: str):
+    from .. import sessions
+
+    arg = args.strip()
+    if arg == "all":
+        n = sessions.delete_all(str(session.config.root))
+        print(color(f"forgot {n} saved session(s) for this directory.", "gray"))
+        return
+    if not arg:
+        eprint(color("usage: /forget <id>|all (see /sessions).", "yellow"))
+        return
+    if sessions.delete(arg):
+        print(color(f"forgot session {arg}.", "gray"))
+    else:
+        eprint(color(f"no session with id '{arg}'.", "yellow"))
+
+
+register(SlashCommand("forget", "delete saved session(s)", _run, usage="<id>|all"))
+

scootcli/commands/help.py

@@ -0,0 +1,29 @@
+"""/help — list available slash-commands."""
+
+from __future__ import annotations
+
+from ..rendering import color
+from . import all_commands, register
+from .base import SlashCommand
+
+
+def _run(session, args: str):
+    if getattr(getattr(session, "config", None), "logo", True):
+        from ..logo import mascot
+
+        for row in mascot("idle", "micro"):
+            print(color(row, "cyan"))
+    print(color("slash-commands:", "bold"))
+    for name, cmd in all_commands().items():
+        usage = f" {cmd.usage}" if cmd.usage else ""
+        print(f"  {color('/' + name, 'cyan')}{usage}  {color('— ' + cmd.summary, 'gray')}")
+    print(color("  (or just type a prompt · esc to interrupt · ctrl-c to quit)", "gray"))
+    print(color("  keys: ↑/↓ recall history · ↓ on a draft clears it (↑ brings it back)", "gray"))
+    print(color("  feed detail: /verbosity full|compact|quiet (collapse tool calls / hide reasoning)",
+                "gray"))
+    print(color("  copy the last reply with /c or Ctrl-S (⌘C can't be captured by a terminal app)",
+                "gray"))
+
+
+register(SlashCommand("help", "show this help", _run))
+

scootcli/commands/init.py

@@ -0,0 +1,50 @@
+"""/init — learn the project and write AGENTS.md (auto-loaded into the system prompt)."""
+
+from __future__ import annotations
+
+from ..activity import activity
+from ..errors import ScootError, Interrupted
+from ..keys import read_key
+from ..project import generate_agents_md
+from ..rendering import color, eprint
+from . import register
+from .base import SlashCommand
+
+
+def _run(session, args: str):
+    root = session.config.root
+    target = root / "AGENTS.md"
+
+    if target.exists():
+        print(color("AGENTS.md already exists — overwrite? [y/N] ", "yellow"), end="", flush=True)
+        key = read_key()
+        print(key)
+        if key != "y":
+            print(color("cancelled.", "gray"))
+            return
+
+    try:
+        with activity("scanning project & writing AGENTS.md…") as cancel:
+            content = generate_agents_md(session, cancel)
+    except Interrupted:
+        print(color("⏹ interrupted", "yellow"))
+        return
+    except ScootError as exc:
+        eprint(color(f"/init failed: {exc}", "red"))
+        return
+
+    if not content:
+        eprint(color("model returned no content.", "yellow"))
+        return
+    try:
+        target.write_text(content, "utf-8")
+    except OSError as exc:
+        eprint(color(f"could not write AGENTS.md: {exc}", "red"))
+        return
+    print(color(
+        f"wrote {target} ({len(content.splitlines())} lines). "
+        "It will load into context automatically on future turns.", "gray"))
+
+
+register(SlashCommand("init", "learn the project → AGENTS.md", _run))
+

scootcli/commands/logo.py

@@ -0,0 +1,51 @@
+"""/logo — show the mascot, or turn it on/off (persisted across launches).
+
+``off`` hides the launch banner art and the face in the status bar; the transcript label is unaffected
+(see ``--no-emoji`` / ``SCOOT_EMOJI`` for that).
+"""
+
+from __future__ import annotations
+
+from .. import logo, preferences
+from ..rendering import color, eprint
+from . import register
+from .base import SlashCommand
+
+_ON = ("on", "true", "1", "yes", "show")
+_OFF = ("off", "false", "0", "no", "hide")
+
+
+def _run(session, args: str):
+    want = (args or "").strip().lower()
+    cfg = session.config
+    if not want:
+        for row in logo.mascot("idle", "lean"):
+            print(color(row, "cyan"))
+        state = "on" if getattr(cfg, "logo", True) else "off"
+        print(color(f"logo: {state}  (usage: /logo on|off · also --no-logo / SCOOT_LOGO=0)", "gray"))
+        return
+    if want in _ON:
+        on = True
+    elif want in _OFF:
+        on = False
+    else:
+        eprint(color(f"unknown option '{want}'. use: /logo on|off", "yellow"))
+        return
+    preferences.set_logo(on)
+    try:
+        session.config = cfg.override(logo=on)  # Config is frozen: swap in a copy for the live session
+    except Exception:
+        pass
+    bar = getattr(session, "status_bar", None)
+    if bar is not None:
+        from ..auth import account_label, auth_source
+        from ..panel import build_status_text
+
+        try:
+            bar.render(build_status_text(session, account_label() or auth_source()))
+        except Exception:
+            pass
+    print(color(f"logo {'on' if on else 'off'} (saved; the banner follows on the next launch).", "gray"))
+
+
+register(SlashCommand("logo", "show the mascot, or /logo on|off to toggle it", _run, usage="[on|off]"))

scootcli/commands/model.py

@@ -0,0 +1,61 @@
+"""/model — list available models or switch the active one ('auto' by default).
+
+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``) so the
+next launch reuses it. An explicit ``--model`` flag or ``SCOOT_MODEL`` still overrides it for that run.
+"""
+
+from __future__ import annotations
+
+from ..preferences import set_model
+from ..providers.base import qualify, split_model_id
+from ..rendering import color
+from . import register
+from .base import SlashCommand
+
+
+def _run(session, args: str):
+    arg = args.strip()
+    available = session.available_models()
+
+    if not arg:
+        print(color(f"models  (preference: {session.model} → active: {session.active_model})", "bold"))
+        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("  use: /model <provider/model> · /model default · /model auto (pick per task)", "gray"))
+        return
+
+    if arg in ("auto", "default"):
+        session.model = arg
+        session.active_model = session.resolved_model()
+        set_model(arg)
+        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}); saved for next launch.", "gray"))
+        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
+    set_model(arg)
+    print(color(f"model set to {arg}; saved for next launch.", "gray"))
+
+
+register(SlashCommand("model", "list or switch model (default|auto|provider/model)", _run, usage="[provider/model|default|auto]"))
+

scootcli/commands/panel.py

@@ -0,0 +1,28 @@
+"""/panel — toggle the persistent bottom status bar on/off."""
+
+from __future__ import annotations
+
+from ..rendering import color, eprint
+from . import register
+from .base import SlashCommand
+
+
+def _run(session, args: str):
+    bar = getattr(session, "status_bar", None)
+    if bar is None:
+        eprint(color("status bar is not available in this context.", "yellow"))
+        return
+    on = bar.toggle()
+    if on:
+        from ..auth import account_label, auth_source
+        from ..panel import build_status_text
+
+        try:
+            bar.render(build_status_text(session, account_label() or auth_source()))
+        except Exception:
+            pass
+    print(color(f"panel {'on' if on else 'off'}.", "gray"))
+
+
+register(SlashCommand("panel", "toggle the bottom status bar", _run))
+

scootcli/commands/reset.py

@@ -0,0 +1,20 @@
+"""/reset — clear the conversation history and context (keeps any loaded project context)."""
+
+from __future__ import annotations
+
+from ..rendering import color
+from . import register
+from .base import SlashCommand
+
+
+def _run(session, args: str):
+    session.reset()
+    redraw = getattr(session, "redraw_home", None)
+    if callable(redraw):
+        redraw("fresh session — conversation + context cleared.")
+    else:
+        print(color("conversation + context cleared — fresh session.", "gray"))
+
+
+register(SlashCommand("reset", "clear the conversation + context", _run))
+

scootcli/commands/resume.py

@@ -0,0 +1,31 @@
+"""/resume [<id>] — reload a saved conversation (defaults to the latest for this directory)."""
+
+from __future__ import annotations
+
+from ..rendering import color, eprint
+from . import register
+from .base import SlashCommand
+
+
+def _run(session, args: str):
+    from .. import sessions
+
+    ident = args.strip()
+    if ident:
+        record = sessions.load(ident)
+        if record is None:
+            eprint(color(f"no session with id '{ident}' (try /sessions).", "yellow"))
+            return
+    else:
+        record = sessions.latest_for_root(str(session.config.root))
+        if record is None:
+            print(color("no saved sessions for this directory.", "gray"))
+            return
+
+    session.apply_record(record)
+    print(color(f"resumed session {record.id} · {len(session.messages)} messages "
+                f"· model {session.active_model}.", "gray"))
+
+
+register(SlashCommand("resume", "resume a saved session", _run, usage="[id]"))
+

scootcli/commands/save.py

@@ -0,0 +1,29 @@
+"""/save <file> — dump the current transcript to a file."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..rendering import color, eprint
+from . import register
+from .base import SlashCommand
+
+
+def _run(session, args: str):
+    target = args.strip() or "scoot-transcript.md"
+    path = Path(target).expanduser()
+    lines = [f"# scoot transcript\n\n_model: {session.resolved_model()}_\n"]
+    for msg in session.messages:
+        role = msg.get("role", "?")
+        content = msg.get("content", "")
+        lines.append(f"\n## {role}\n\n{content}\n")
+    try:
+        path.write_text("".join(lines))
+    except OSError as exc:
+        eprint(color(f"could not write {path}: {exc}", "red"))
+        return
+    print(color(f"saved transcript → {path}", "gray"))
+
+
+register(SlashCommand("save", "save the transcript", _run, usage="<file>"))
+

scootcli/commands/sessions.py

@@ -0,0 +1,42 @@
+"""/sessions — list saved sessions for this workspace root (resume with /resume <id>)."""
+
+from __future__ import annotations
+
+import time
+
+from ..rendering import color
+from . import register
+from .base import SlashCommand
+
+
+def _ago(ts: float) -> str:
+    if not ts:
+        return "?"
+    secs = max(0, int(time.time() - ts))
+    if secs < 60:
+        return f"{secs}s ago"
+    if secs < 3600:
+        return f"{secs // 60}m ago"
+    if secs < 86400:
+        return f"{secs // 3600}h ago"
+    return f"{secs // 86400}d ago"
+
+
+def _run(session, args: str):
+    from .. import sessions
+
+    records = sessions.list_sessions(str(session.config.root))
+    if not records:
+        print(color("no saved sessions for this directory.", "gray"))
+        return
+    print(color("saved sessions (this directory):", "bold"))
+    for rec in records:
+        marker = color(" ← current", "green") if rec.id == session.id else ""
+        print(f"  {color(rec.id, 'cyan')}  {color(_ago(rec.updated), 'gray'):<20} "
+              f"{rec.turns} turns · {rec.active_model or rec.model}{marker}")
+        print(f"      {color(rec.first_prompt(), 'gray')}")
+    print(color("resume with: /resume <id>", "gray"))
+
+
+register(SlashCommand("sessions", "list saved sessions", _run))
+

scootcli/commands/status.py

@@ -0,0 +1,59 @@
+"""/status — show current model, token usage, root, and session info."""
+
+from __future__ import annotations
+
+from ..rendering import color
+from . import register
+from .base import SlashCommand
+
+
+def _run(session, args: str):
+    cfg = session.config
+    try:
+        provider_row = session.provider.default_name
+        from ..auth import key_source
+
+        src = key_source(session.provider.spec)
+        provider_row += f"  (key: {src})" if src else ("" if not session.provider.spec.key_required
+                                                       else "  (no key)")
+    except Exception:
+        provider_row = getattr(cfg, "provider", "") or "?"
+    rows = [
+        ("provider", provider_row),
+        ("model", session.active_model + ("  (auto)" if session.model.lower() == "auto" else "")),
+        ("effort", getattr(cfg, "effort", "medium")),
+        ("env files", ", ".join(getattr(cfg, "env_files", ()) or ()) or "none"),
+        ("root", str(cfg.root)),
+        ("approval", session.approval_mode),
+        ("streaming", "on" if getattr(cfg, "stream", True) else "off"),
+        ("panel", "on" if getattr(session, "status_bar", None) and session.status_bar.enabled
+                  else "off"),
+        ("input dock", "on" if getattr(session, "dock", False) else "off"),
+        ("resume", getattr(cfg, "resume", "hint")),
+        ("workspace context", "on" if getattr(cfg, "workspace_context", True) else "off"),
+        ("feed verbosity", getattr(getattr(session, "ui", None), "verbosity",
+                                   getattr(cfg, "verbosity", "full"))),
+        ("max steps", str(cfg.max_steps)),
+        ("turns", str(len(session.messages))),
+        ("tokens (session)", f"prompt={session.total_prompt} completion={session.total_completion}"),
+        ("tokens (last)", f"prompt={session.last_usage.get('prompt_tokens', '?')} "
+                          f"completion={session.last_usage.get('completion_tokens', '?')}"),
+    ]
+    print(color("status:", "bold"))
+    for label, value in rows:
+        print(f"  {color(label + ':', 'gray'):<28} {value}")
+    trusted = getattr(session, "trusted_tools", None)
+    if trusted:
+        print(f"  {color('trusted tools:', 'gray'):<28} {', '.join(sorted(trusted))}")
+    if getattr(session, "worktree", None) is not None:
+        print(f"  {color('worktree:', 'gray'):<28} {session.worktree.branch}")
+    plan = getattr(session, "plan", None)
+    if plan:
+        done = sum(1 for s in plan if s.get("status") == "completed")
+        current = next((s.get("step", "") for s in plan if s.get("status") == "in_progress"), "")
+        detail = f"{done}/{len(plan)}" + (f" · now: {current}" if current else "")
+        print(f"  {color('plan:', 'gray'):<28} {detail}")
+
+
+register(SlashCommand("status", "show model + token usage", _run))
+

scootcli/commands/verbosity.py

@@ -0,0 +1,57 @@
+"""/verbosity — regulate how much of a turn's "thinking" shows in the feed.
+
+Levels (see :class:`scootcli.repl.ReplUI`):
+  * ``full``    — reasoning narration shown; every tool-in-use line kept in the feed (a run log).
+  * ``compact`` — reasoning narration shown; tool-in-use is one transient line above the spinner,
+                  removed once the tool finishes (nothing accumulates).
+  * ``quiet``   — reasoning narration suppressed; tools render like ``compact``.
+"""
+
+from __future__ import annotations
+
+from ..rendering import color, eprint
+from . import register
+from .base import SlashCommand
+
+_LEVELS = ("full", "compact", "quiet")
+_ALIASES = {"default": "full", "collapse": "compact", "collapsed": "compact",
+            "off": "quiet", "min": "quiet", "minimal": "quiet"}
+_HELP = {
+    "full": "show reasoning + keep every tool call in the feed",
+    "compact": "show reasoning; collapse tool calls to one transient line above Thinking…",
+    "quiet": "hide reasoning; collapse tool calls",
+}
+
+
+def _run(session, args: str):
+    ui = getattr(session, "ui", None)
+    if ui is None:
+        eprint(color("verbosity is not available in this context.", "yellow"))
+        return
+
+    want = (args or "").strip().lower()
+    if not want:
+        cur = getattr(ui, "verbosity", "full")
+        print(color(f"feed verbosity: {cur}", "bold"))
+        for lvl in _LEVELS:
+            mark = color("●", "cyan") if lvl == cur else color("○", "gray")
+            print(f"  {mark} {color(lvl, 'bold')}  {color('— ' + _HELP[lvl], 'gray')}")
+        print(color("  usage: /verbosity full|compact|quiet", "gray"))
+        return
+
+    level = _ALIASES.get(want, want)
+    if level not in _LEVELS:
+        eprint(color(f"unknown level '{want}'. use: full | compact | quiet", "yellow"))
+        return
+    ui.verbosity = level
+    try:
+        session.config.verbosity = level  # keep config in sync (surfaced in /status)
+    except Exception:
+        pass
+    print(color(f"feed verbosity → {level}  ({_HELP[level]})", "gray"))
+
+
+register(SlashCommand(
+    "verbosity", "regulate feed detail (full|compact|quiet)", _run,
+    usage="[full|compact|quiet]",
+))

scootcli/commands/worktree.py

@@ -0,0 +1,64 @@
+"""/worktree — isolate autonomous work in a throwaway git worktree, then review & merge (M5.1b)."""
+
+from __future__ import annotations
+
+from ..rendering import color, eprint
+from .. import worktree as wt
+from . import register
+from .base import SlashCommand
+
+_ACTIONS = ("merge", "keep", "discard")
+
+
+def _start(session):
+    if session.worktree is not None:
+        print(color(f"already in worktree {session.worktree.branch}.", "yellow"))
+        return
+    root = session.config.root
+    if not wt.is_git_repo(root):
+        print(color("not a git repo — worktree isolation unavailable here.", "yellow"))
+        print(color("  tip: use /yolo in place, or `git init` first.", "gray"))
+        return
+    try:
+        w = wt.start(root)
+    except Exception as exc:  # git failure
+        eprint(color(f"could not create worktree: {exc}", "red"))
+        return
+    session.worktree = w
+    session.config = session.config.override(root=str(w.path))
+    print(color(f"⚙ isolated in worktree {w.branch}", "cyan"))
+    print(color(f"  root → {w.path}", "gray"))
+    print(color("  work freely (try /yolo); then /worktree merge|keep|discard", "gray"))
+
+
+def _finish(session, action):
+    w = session.worktree
+    if w is None:
+        print(color("not in a worktree.", "yellow"))
+        return
+    msg = wt.finish(w, action)
+    session.config = session.config.override(root=str(w.original_root))
+    session.worktree = None
+    print(color(f"{msg}", "gray"))
+    print(color(f"  root → {w.original_root}", "gray"))
+
+
+def _run(session, args: str):
+    sub = (args.strip() or "start").split()[0].lower()
+    if sub in ("start", "on"):
+        _start(session)
+    elif sub == "diff":
+        if session.worktree is None:
+            print(color("not in a worktree.", "yellow"))
+            return
+        d = wt.diff(session.worktree)
+        print(d or color("(no changes yet)", "gray"))
+    elif sub in _ACTIONS:
+        _finish(session, sub)
+    else:
+        print(color(f"usage: /worktree start|diff|{'|'.join(_ACTIONS)}", "gray"))
+
+
+register(SlashCommand("worktree", "isolate work in a git worktree, then merge/keep/discard",
+                      _run, usage="start|diff|merge|keep|discard"))
+

scootcli/commands/yolo.py

@@ -0,0 +1,20 @@
+"""/yolo — shortcut to switch the session into yolo approval mode (auto-approve all)."""
+
+from __future__ import annotations
+
+from ..rendering import color
+from . import register
+from .base import SlashCommand
+
+
+def _run(session, args: str):
+    session.approval_mode = "yolo"
+    print(color("⚡ yolo mode ON — tool calls run without asking.", "yellow"))
+    print(color("  (destructive shell commands are still confirmed; /approve always to revert)", "gray"))
+    if args.strip().lower() in ("worktree", "wt", "--worktree"):
+        from . import get
+        get("worktree").handler(session, "start")
+
+
+register(SlashCommand("yolo", "auto-approve all tool calls this session", _run, usage="[worktree]"))
+