scootcli 0.6.0__tar.gz → 0.7.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scootcli
-Version: 0.6.0
+Version: 0.7.0
 Summary: A tiny coding agent that goes where you point it
 Author: Sergey Nes
 License-Expression: MIT
@@ -259,12 +259,13 @@ Put them in `~/.config/scoot/hooks.json` or `.scoot/hooks.json` in the project:
 }
 ```
 
-A `PreToolUse` hook can answer `{"permissionDecision": "deny", "reason": "..."}` to skip a tool (the model is told why), `allow` to skip the approval prompt, or `ask` to force one even in `yolo`; exit code 2 denies with stderr as the reason.
+A `PreToolUse` hook can answer `{"permissionDecision": "deny", "reason": "..."}` to skip a tool (the model is told why), `allow` to skip the approval prompt, or `ask` to force one even in `yolo`; exit code 2 denies with stderr as the reason. Claude Code's nested `hookSpecificOutput` answer is accepted as is, so a hook written for Claude Code works without edits.
 A `Stop` hook that answers `{"decision": "block", "reason": "run the tests first"}` sends the agent back to work with that instruction, at most three times per turn.
+Matchers understand Claude Code's tool names as well as scoot's, so `"matcher": "Bash|Write|Edit"` fires for `run_shell`, `write_file`, and `edit_file`, and the payload carries the alias as `tool_alias`: one `hooks.json` and one script can serve both tools.
 `/hooks` shows what is configured and what ran; `SCOOT_HOOKS=0` turns hooks off.
 
 **Headless mode** is for editors, automation, and remote-control tools: `scoot --headless` reads JSON lines on stdin (`prompt`, `approve`, `note`, `interrupt`, `command`, `shutdown`) and writes JSON lines on stdout (streamed text, tool calls, approval requests, results, plan updates, usage, errors, a heartbeat), with nothing else ever printed there.
-Same sessions, tools, approvals, routing, and hooks as the REPL.
+Same sessions, tools, approvals, routing, and hooks as the REPL; every `turn_end` carries the turn's tokens and cost, and `--json` one-shot output carries `cost` too.
 The message tables and a full transcript are in [`docs/headless-protocol.md`](./docs/headless-protocol.md); an unanswered approval is denied after `SCOOT_APPROVAL_TIMEOUT` seconds (default 120).
 
 ### The status bar
@@ -276,14 +277,26 @@ The bottom row shows the mascot's face (its eyes follow the turn: `o o` idle, `>
 ```bash
 pipx install scootcli && pipx ensurepath       # recommended: isolated; ensurepath puts ~/.local/bin on PATH for new shells
 curl -fsSL https://raw.githubusercontent.com/sergenes/scootcli/main/install.sh | bash   # no pipx: puts the zipapp at ~/.local/bin/scoot
-pip install scootcli                           # anywhere
+pip install scootcli                           # inside a venv, container, or CI job (system Pythons on recent Linux and Homebrew block pip outside a venv)
 curl -LO https://github.com/sergenes/scootcli/releases/latest/download/scoot.pyz && python3 scoot.pyz  # single file, no install
 git clone https://github.com/sergenes/scootcli && cd scootcli && pip install -e .                       # from source
 ```
 
 The install script needs only `curl` and Python 3.9+. `SCOOT_VERSION=v0.2.0` pins a release and `SCOOT_INSTALL_DIR` changes the target; read it before you run it, it is sixty lines.
-**Upgrading.** `pipx upgrade scootcli`, or `pip install --upgrade scootcli`, or rerun the curl line, which always fetches the latest release; `scoot --version` shows what you have, and `scoot --check-update` asks PyPI whether a newer one exists. With `SCOOT_UPDATE_CHECK=1` the REPL checks once in the background at start and shows `⬆ x.y.z` in the status bar; nothing contacts PyPI otherwise.
-`bash install.sh --uninstall` removes the command installed by the script (pipx users: `pipx uninstall scootcli`); config and sessions stay.
+## Upgrade options
+
+Use the same tool you installed with:
+
+```bash
+pipx upgrade scootcli                          # pipx install
+pip install --upgrade scootcli                 # pip install
+curl -fsSL https://raw.githubusercontent.com/sergenes/scootcli/main/install.sh | bash   # the curl installer: rerun it, it always fetches the latest release
+scoot --version                                # what you have
+scoot --check-update                           # ask PyPI whether a newer release exists
+```
+
+With `SCOOT_UPDATE_CHECK=1` the REPL checks once in the background at start and shows `⬆ x.y.z` in the status bar; nothing contacts PyPI otherwise.
+To remove scoot: `pipx uninstall scootcli`, `pip uninstall scootcli`, or `bash install.sh --uninstall` for the curl installer; config in `~/.config/scoot` and sessions in `~/.local/state/scoot` stay either way.
 
 Both pipx and the script install into `~/.local/bin`. On a fresh Linux account that directory is added to PATH at login only if it already exists, so after the very first install either open a new login shell or run `pipx ensurepath`; the installer prints the exact line for your shell.
 

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

@@ -234,12 +234,13 @@ Put them in `~/.config/scoot/hooks.json` or `.scoot/hooks.json` in the project:
 }
 ```
 
-A `PreToolUse` hook can answer `{"permissionDecision": "deny", "reason": "..."}` to skip a tool (the model is told why), `allow` to skip the approval prompt, or `ask` to force one even in `yolo`; exit code 2 denies with stderr as the reason.
+A `PreToolUse` hook can answer `{"permissionDecision": "deny", "reason": "..."}` to skip a tool (the model is told why), `allow` to skip the approval prompt, or `ask` to force one even in `yolo`; exit code 2 denies with stderr as the reason. Claude Code's nested `hookSpecificOutput` answer is accepted as is, so a hook written for Claude Code works without edits.
 A `Stop` hook that answers `{"decision": "block", "reason": "run the tests first"}` sends the agent back to work with that instruction, at most three times per turn.
+Matchers understand Claude Code's tool names as well as scoot's, so `"matcher": "Bash|Write|Edit"` fires for `run_shell`, `write_file`, and `edit_file`, and the payload carries the alias as `tool_alias`: one `hooks.json` and one script can serve both tools.
 `/hooks` shows what is configured and what ran; `SCOOT_HOOKS=0` turns hooks off.
 
 **Headless mode** is for editors, automation, and remote-control tools: `scoot --headless` reads JSON lines on stdin (`prompt`, `approve`, `note`, `interrupt`, `command`, `shutdown`) and writes JSON lines on stdout (streamed text, tool calls, approval requests, results, plan updates, usage, errors, a heartbeat), with nothing else ever printed there.
-Same sessions, tools, approvals, routing, and hooks as the REPL.
+Same sessions, tools, approvals, routing, and hooks as the REPL; every `turn_end` carries the turn's tokens and cost, and `--json` one-shot output carries `cost` too.
 The message tables and a full transcript are in [`docs/headless-protocol.md`](./docs/headless-protocol.md); an unanswered approval is denied after `SCOOT_APPROVAL_TIMEOUT` seconds (default 120).
 
 ### The status bar
@@ -251,14 +252,26 @@ The bottom row shows the mascot's face (its eyes follow the turn: `o o` idle, `>
 ```bash
 pipx install scootcli && pipx ensurepath       # recommended: isolated; ensurepath puts ~/.local/bin on PATH for new shells
 curl -fsSL https://raw.githubusercontent.com/sergenes/scootcli/main/install.sh | bash   # no pipx: puts the zipapp at ~/.local/bin/scoot
-pip install scootcli                           # anywhere
+pip install scootcli                           # inside a venv, container, or CI job (system Pythons on recent Linux and Homebrew block pip outside a venv)
 curl -LO https://github.com/sergenes/scootcli/releases/latest/download/scoot.pyz && python3 scoot.pyz  # single file, no install
 git clone https://github.com/sergenes/scootcli && cd scootcli && pip install -e .                       # from source
 ```
 
 The install script needs only `curl` and Python 3.9+. `SCOOT_VERSION=v0.2.0` pins a release and `SCOOT_INSTALL_DIR` changes the target; read it before you run it, it is sixty lines.
-**Upgrading.** `pipx upgrade scootcli`, or `pip install --upgrade scootcli`, or rerun the curl line, which always fetches the latest release; `scoot --version` shows what you have, and `scoot --check-update` asks PyPI whether a newer one exists. With `SCOOT_UPDATE_CHECK=1` the REPL checks once in the background at start and shows `⬆ x.y.z` in the status bar; nothing contacts PyPI otherwise.
-`bash install.sh --uninstall` removes the command installed by the script (pipx users: `pipx uninstall scootcli`); config and sessions stay.
+## Upgrade options
+
+Use the same tool you installed with:
+
+```bash
+pipx upgrade scootcli                          # pipx install
+pip install --upgrade scootcli                 # pip install
+curl -fsSL https://raw.githubusercontent.com/sergenes/scootcli/main/install.sh | bash   # the curl installer: rerun it, it always fetches the latest release
+scoot --version                                # what you have
+scoot --check-update                           # ask PyPI whether a newer release exists
+```
+
+With `SCOOT_UPDATE_CHECK=1` the REPL checks once in the background at start and shows `⬆ x.y.z` in the status bar; nothing contacts PyPI otherwise.
+To remove scoot: `pipx uninstall scootcli`, `pip uninstall scootcli`, or `bash install.sh --uninstall` for the curl installer; config in `~/.config/scoot` and sessions in `~/.local/state/scoot` stay either way.
 
 Both pipx and the script install into `~/.local/bin`. On a fresh Linux account that directory is added to PATH at login only if it already exists, so after the very first install either open a new login shell or run `pipx ensurepath`; the installer prints the exact line for your shell.
 

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

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

{scootcli-0.6.0 → scootcli-0.7.0}/src/scootcli/agent.py

@@ -219,8 +219,10 @@ class Agent:
             return "", ""
         from .hooks import tool_kind
 
+        from .hooks import tool_alias
+
         payload = hooks.payload(session, "PreToolUse", tool_name=tool.name, tool_input=args,
-                                tool_kind=tool_kind(tool))
+                                tool_kind=tool_kind(tool), tool_alias=tool_alias(tool.name))
         decision = hooks.run("PreToolUse", payload, cancel_event)
         return decision.action, decision.reason
 
@@ -232,9 +234,11 @@ class Agent:
 
         response = {"ok": result.ok, "summary": result.summary or "", "error": result.error or "",
                     "content": (result.content or "")[:4000]}
+        from .hooks import tool_alias
+
         hooks.run("PostToolUse", hooks.payload(session, "PostToolUse", tool_name=tool.name,
                                                tool_input=args, tool_kind=tool_kind(tool),
-                                               tool_response=response))
+                                               tool_alias=tool_alias(tool.name), tool_response=response))
 
     @staticmethod
     def _last_user_text(session) -> str:

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

@@ -194,6 +194,7 @@ def _run_once(config: Config, pool: ProviderPool, prompt: str, as_json: bool, re
             "content": outcome.content,
             "error": outcome.error,
             "usage": session.last_usage,
+            "cost": session.session_cost(),
         }, indent=2))
         return 0 if outcome.status == "done" else 1
 

{scootcli-0.6.0 → scootcli-0.7.0}/src/scootcli/headless.py

@@ -285,6 +285,7 @@ class Headless:
         self.cancel = threading.Event()
         self.ui.cancel_event = self.cancel
         self.session.last_error = ""
+        before = self._session_cost()
         try:
             with redirect_stdout(sys.stderr):  # any stray print from a tool or command stays off the protocol
                 try:
@@ -303,6 +304,7 @@ class Headless:
                 self.writer.emit("error", message=outcome.error, kind="turn")
             self.writer.emit("turn_end", turn=self._turn, status=outcome.status, steps=outcome.steps,
                              model=self.session.active_model, usage=self.session.last_usage,
+                             cost=self._turn_cost(before), cost_session=self._session_cost(),
                              content=outcome.content, error=outcome.error)
         except ScootError as exc:
             self.writer.emit("error", message=str(exc), hint=getattr(exc, "hint", ""), kind="turn")
@@ -313,6 +315,19 @@ class Headless:
             self.cancel = None
             self.ui.cancel_event = None
 
+    def _session_cost(self):
+        fn = getattr(self.session, "session_cost", None)
+        try:
+            return fn() if callable(fn) else None
+        except Exception:
+            return None
+
+    def _turn_cost(self, before):
+        after = self._session_cost()
+        if after is None or before is None:
+            return None
+        return round(after - before, 6)
+
     def _command(self, msg: dict) -> None:
         from . import commands
         import io

{scootcli-0.6.0 → scootcli-0.7.0}/src/scootcli/hooks.py

@@ -36,6 +36,12 @@ EVENTS = ("SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop
 DEFAULT_TIMEOUT = 60
 _MAX_CAPTURE = 16_000
 _TOOL_KINDS = {"read": "read", "write": "write", "shell": "shell"}
+# Claude Code's names for the same jobs, so a hooks.json written for it ("matcher": "Bash|Write|Edit")
+# fires for scoot's tools too, and a shared script can switch on ``tool_alias``.
+TOOL_ALIASES = {
+    "read_file": "Read", "list_dir": "LS", "search": "Grep", "write_file": "Write", "edit_file": "Edit",
+    "run_shell": "Bash", "open_editor": "Open", "update_plan": "TodoWrite",
+}
 
 
 @dataclass
@@ -96,6 +102,19 @@ def tool_kind(tool) -> str:
     return _TOOL_KINDS.get(getattr(tool, "risk", ""), "read")
 
 
+def tool_alias(name: str) -> str:
+    return TOOL_ALIASES.get(name, name)
+
+
+def matcher_hits(matcher: str, tool_name: str) -> bool:
+    """A matcher regex matches scoot's tool name or its Claude Code alias."""
+    try:
+        rx = re.compile(str(matcher))
+    except re.error:
+        return False
+    return bool(rx.search(tool_name) or rx.search(tool_alias(tool_name)))
+
+
 class Hooks:
     """The merged hook configuration for one workspace, plus a record of what ran."""
 
@@ -149,10 +168,7 @@ class Hooks:
         for entry in self.config.get(event, []):
             matcher = entry.get("matcher")
             if matcher and event in ("PreToolUse", "PostToolUse"):
-                try:
-                    if not re.search(str(matcher), tool_name):
-                        continue
-                except re.error:
+                if not matcher_hits(matcher, tool_name):
                     continue
             for hook in entry.get("hooks", []):
                 if not isinstance(hook, dict) or hook.get("type", "command") != "command":
@@ -212,7 +228,21 @@ class Hooks:
     @staticmethod
     def _interpret(event: str, data: dict) -> Decision:
         reason = str(data.get("reason") or "")
-        perm = str(data.get("permissionDecision") or "").lower()
+        # Claude Code nests a hook's decision under "hookSpecificOutput" (with the reason as
+        # "permissionDecisionReason" and extra context as "additionalContext"); scoot's own flat
+        # shape puts the same keys at the top level. Read both, nested first.
+        hso = data.get("hookSpecificOutput")
+        if isinstance(hso, dict):
+            if not reason:
+                reason = str(hso.get("permissionDecisionReason") or hso.get("reason") or "")
+            perm_src = hso.get("permissionDecision")
+            context_src = hso.get("additionalContext")
+        else:
+            perm_src = data.get("permissionDecision")
+            context_src = None
+        perm = str(perm_src or "").lower()
+        if perm == "approve":
+            perm = "allow"  # Claude Code's older synonym
         if event == "PreToolUse" and perm in ("allow", "deny", "ask"):
             return Decision(action=perm, reason=reason)
         raw = str(data.get("decision") or "").lower()
@@ -220,7 +250,7 @@ class Hooks:
             return Decision(action="deny" if event == "PreToolUse" else "block", reason=reason)
         if raw == "approve" and event == "PreToolUse":
             return Decision(action="allow", reason=reason)
-        context = data.get("additionalContext") or data.get("context") or ""
+        context = context_src or data.get("additionalContext") or data.get("context") or ""
         return Decision(context=str(context) if context else "")
 
     def _record(self, event: str, command: str, outcome: str, detail: str, started: float) -> None:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scootcli
-Version: 0.6.0
+Version: 0.7.0
 Summary: A tiny coding agent that goes where you point it
 Author: Sergey Nes
 License-Expression: MIT
@@ -259,12 +259,13 @@ Put them in `~/.config/scoot/hooks.json` or `.scoot/hooks.json` in the project:
 }
 ```
 
-A `PreToolUse` hook can answer `{"permissionDecision": "deny", "reason": "..."}` to skip a tool (the model is told why), `allow` to skip the approval prompt, or `ask` to force one even in `yolo`; exit code 2 denies with stderr as the reason.
+A `PreToolUse` hook can answer `{"permissionDecision": "deny", "reason": "..."}` to skip a tool (the model is told why), `allow` to skip the approval prompt, or `ask` to force one even in `yolo`; exit code 2 denies with stderr as the reason. Claude Code's nested `hookSpecificOutput` answer is accepted as is, so a hook written for Claude Code works without edits.
 A `Stop` hook that answers `{"decision": "block", "reason": "run the tests first"}` sends the agent back to work with that instruction, at most three times per turn.
+Matchers understand Claude Code's tool names as well as scoot's, so `"matcher": "Bash|Write|Edit"` fires for `run_shell`, `write_file`, and `edit_file`, and the payload carries the alias as `tool_alias`: one `hooks.json` and one script can serve both tools.
 `/hooks` shows what is configured and what ran; `SCOOT_HOOKS=0` turns hooks off.
 
 **Headless mode** is for editors, automation, and remote-control tools: `scoot --headless` reads JSON lines on stdin (`prompt`, `approve`, `note`, `interrupt`, `command`, `shutdown`) and writes JSON lines on stdout (streamed text, tool calls, approval requests, results, plan updates, usage, errors, a heartbeat), with nothing else ever printed there.
-Same sessions, tools, approvals, routing, and hooks as the REPL.
+Same sessions, tools, approvals, routing, and hooks as the REPL; every `turn_end` carries the turn's tokens and cost, and `--json` one-shot output carries `cost` too.
 The message tables and a full transcript are in [`docs/headless-protocol.md`](./docs/headless-protocol.md); an unanswered approval is denied after `SCOOT_APPROVAL_TIMEOUT` seconds (default 120).
 
 ### The status bar
@@ -276,14 +277,26 @@ The bottom row shows the mascot's face (its eyes follow the turn: `o o` idle, `>
 ```bash
 pipx install scootcli && pipx ensurepath       # recommended: isolated; ensurepath puts ~/.local/bin on PATH for new shells
 curl -fsSL https://raw.githubusercontent.com/sergenes/scootcli/main/install.sh | bash   # no pipx: puts the zipapp at ~/.local/bin/scoot
-pip install scootcli                           # anywhere
+pip install scootcli                           # inside a venv, container, or CI job (system Pythons on recent Linux and Homebrew block pip outside a venv)
 curl -LO https://github.com/sergenes/scootcli/releases/latest/download/scoot.pyz && python3 scoot.pyz  # single file, no install
 git clone https://github.com/sergenes/scootcli && cd scootcli && pip install -e .                       # from source
 ```
 
 The install script needs only `curl` and Python 3.9+. `SCOOT_VERSION=v0.2.0` pins a release and `SCOOT_INSTALL_DIR` changes the target; read it before you run it, it is sixty lines.
-**Upgrading.** `pipx upgrade scootcli`, or `pip install --upgrade scootcli`, or rerun the curl line, which always fetches the latest release; `scoot --version` shows what you have, and `scoot --check-update` asks PyPI whether a newer one exists. With `SCOOT_UPDATE_CHECK=1` the REPL checks once in the background at start and shows `⬆ x.y.z` in the status bar; nothing contacts PyPI otherwise.
-`bash install.sh --uninstall` removes the command installed by the script (pipx users: `pipx uninstall scootcli`); config and sessions stay.
+## Upgrade options
+
+Use the same tool you installed with:
+
+```bash
+pipx upgrade scootcli                          # pipx install
+pip install --upgrade scootcli                 # pip install
+curl -fsSL https://raw.githubusercontent.com/sergenes/scootcli/main/install.sh | bash   # the curl installer: rerun it, it always fetches the latest release
+scoot --version                                # what you have
+scoot --check-update                           # ask PyPI whether a newer release exists
+```
+
+With `SCOOT_UPDATE_CHECK=1` the REPL checks once in the background at start and shows `⬆ x.y.z` in the status bar; nothing contacts PyPI otherwise.
+To remove scoot: `pipx uninstall scootcli`, `pip uninstall scootcli`, or `bash install.sh --uninstall` for the curl installer; config in `~/.config/scoot` and sessions in `~/.local/state/scoot` stay either way.
 
 Both pipx and the script install into `~/.local/bin`. On a fresh Linux account that directory is added to PATH at login only if it already exists, so after the very first install either open a new login shell or run `pipx ensurepath`; the installer prints the exact line for your shell.
 

{scootcli-0.6.0 → scootcli-0.7.0}/tests/test_headless.py

@@ -129,6 +129,7 @@ def test_full_turn_with_approval_round_trip(tmp_path):
     stdin.send({"type": "approve", "id": req["id"], "decision": "allow"})
     end = out.wait_for("turn_end")
     assert end["status"] == "done" and end["content"] == "It says hello." and end["turn"] == 1
+    assert "cost" in end and "cost_session" in end  # None here (model "m" has no price), present always
     types = [e["type"] for e in out.events()]
     assert types.index("tool_call") < types.index("tool_result") < types.index("turn_end")
     assert out.wait_for("tool_result")["ok"] is True and "hello" in out.wait_for("tool_result")["content"]

{scootcli-0.6.0 → scootcli-0.7.0}/tests/test_hooks.py

@@ -240,3 +240,36 @@ def test_tool_kind_mapping():
     assert H.tool_kind(tools.get("edit_file")) == "write"
     assert H.tool_kind(tools.get("run_shell")) == "shell"
     assert H.tool_kind(tools.get("update_plan")) == "meta"
+
+
+def test_interpret_accepts_claude_codes_nested_output():
+    from scootcli.hooks import Hooks
+
+    i = Hooks._interpret
+    assert i("PreToolUse", {"hookSpecificOutput": {"permissionDecision": "allow"}}).action == "allow"
+    d = i("PreToolUse", {"hookSpecificOutput": {"permissionDecision": "deny", "permissionDecisionReason": "no"}})
+    assert d.action == "deny" and d.reason == "no"
+    assert i("PreToolUse", {"hookSpecificOutput": {"permissionDecision": "approve"}}).action == "allow"
+    assert i("PreToolUse", {"hookSpecificOutput": {"permissionDecision": "ask"}}).action == "ask"
+    # extra context nested the way Claude Code emits it for UserPromptSubmit / PostToolUse
+    c = i("UserPromptSubmit", {"hookSpecificOutput": {"hookEventName": "UserPromptSubmit", "additionalContext": "branch: main"}})
+    assert c.action == "" and c.context == "branch: main"
+    # the pre-existing flat shapes still work
+    assert i("PreToolUse", {"permissionDecision": "deny", "reason": "flat"}).reason == "flat"
+    assert i("Stop", {"decision": "block", "reason": "more"}).action == "block"
+    assert i("PreToolUse", {"decision": "approve"}).action == "allow"
+    assert i("PreToolUse", {"additionalContext": "x"}).context == "x"
+
+
+def test_matcher_matches_claude_code_tool_names(tmp_path):
+    from scootcli.hooks import matcher_hits, tool_alias
+
+    assert tool_alias("run_shell") == "Bash" and tool_alias("edit_file") == "Edit" and tool_alias("nope") == "nope"
+    assert matcher_hits("Bash|Write|Edit", "run_shell") and matcher_hits("Bash|Write|Edit", "edit_file")
+    assert not matcher_hits("Bash|Write|Edit", "read_file")
+    assert matcher_hits("run_shell", "run_shell") and matcher_hits("^Read$", "read_file")
+    assert not matcher_hits("[", "run_shell")  # a broken regex never matches
+    deny = _script(tmp_path, "denybash", 'print(json.dumps({"permissionDecision": "deny", "reason": "claude-style matcher"}))')
+    h = _hooks(tmp_path, {"PreToolUse": [{"matcher": "Bash", "hooks": [{"command": deny}]}]})
+    assert h.run("PreToolUse", {"tool_name": "run_shell"}).action == "deny"
+    assert h.run("PreToolUse", {"tool_name": "read_file"}).action == ""

{scootcli-0.6.0 → scootcli-0.7.0}/tests/test_small_060.py

@@ -180,3 +180,23 @@ def test_install_script_uninstall(tmp_path):
     out = subprocess.run(["bash", str(script), "--uninstall"], capture_output=True, text=True,
                          env={"SCOOT_INSTALL_DIR": str(tmp_path), "PATH": "/usr/bin:/bin", "HOME": str(tmp_path)})
     assert "nothing to remove" in out.stdout
+
+
+def test_one_shot_json_includes_cost(monkeypatch, tmp_path, capsys):
+    from scootcli import cli
+    from scootcli.providers import ChatResult, registry
+
+    monkeypatch.setenv("OPENAI_API_KEY", "sk-test-000000000000")
+
+    class _P:
+        def chat(self, messages, **k):
+            return ChatResult(content="pong", model="openai/gpt-5.3-codex",
+                              usage={"prompt_tokens": 1_000_000, "completion_tokens": 0})
+
+        def list_models(self, cancel_event=None):
+            return []
+
+    monkeypatch.setattr(registry, "make_provider", lambda name, config, transport=None: _P())
+    rc = cli.main(["--root", str(tmp_path), "--no-workspace", "--json", "--model", "openai/gpt-5.3-codex", "ping"])
+    out = json.loads(capsys.readouterr().out)
+    assert rc == 0 and abs(out["cost"] - 1.75) < 1e-9