euron-code 0.1.0__py3-none-any.whl

euron_code/__init__.py

@@ -0,0 +1,3 @@
+"""Euron Code: an agentic coding assistant for the terminal."""
+
+__version__ = "0.1.0"

euron_code/__main__.py

@@ -0,0 +1,4 @@
+from euron_code.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

euron_code/agent.py

@@ -0,0 +1,595 @@
+"""The agent loop: stream a model response, run its tool calls, repeat until it answers.
+
+Rules this file enforces:
+- One model request at a time (never parallel), including sub-agents and compaction.
+- Reasoning (`delta.reasoning`) is displayed or hidden, never stored or resent.
+- The system prompt and tool list are byte-stable and first in every request (prefix cache).
+- Retry only before any output was shown (spec §4); a mid-stream failure stops the turn.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import threading
+import time
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+from euron_code import api, context, memory, prompts
+from euron_code.api import (BusyError, ContextTooLongError, EuronError, Interrupted, MidStreamError,
+                            NetworkError, RateLimitedError)
+from euron_code.keys import EscWatcher
+from euron_code.permissions import Permissions, Request
+from euron_code.sessions import SessionWriter
+from euron_code.tools import ToolContext, ToolError, ToolResult, default_tools, read_only_tools
+from euron_code.tools.base import ReadTracker
+from euron_code.tools.shell import detect_shell
+from euron_code.tools.todo import render_todos
+
+BUSY_BACKOFF = [5, 10, 20, 40, 40]  # spec §4: 5, 10, 20, 40 s, max 5 tries
+RATE_LIMIT_FALLBACK = 20
+MAX_RATE_LIMIT_RETRIES = 5
+NETWORK_BACKOFF = [2, 4, 8]
+DENIED = "denied"
+
+
+@dataclass
+class Response:
+    content: str = ""
+    tool_calls: List[Dict[str, Any]] = field(default_factory=list)
+    usage: Optional[Dict[str, Any]] = None
+    finish_reason: Optional[str] = None
+    reasoning_chars: int = 0
+
+
+@dataclass
+class TurnResult:
+    text: str
+    stop_reason: str  # end_turn | max_turns | interrupted | denied | error
+    turns: int
+    error: Optional[EuronError] = None
+
+
+TOOL_CALL_TAG = re.compile(r"<tool_call>\s*(\{.*?\})\s*</tool_call>", re.DOTALL)
+
+
+def parse_inline_tool_calls(content: str):
+    """Fallback for servers without a tool parser: Qwen emits <tool_call>{json}</tool_call>."""
+    calls = []
+    for m in TOOL_CALL_TAG.finditer(content):
+        try:
+            obj = json.loads(m.group(1))
+        except ValueError:
+            continue
+        name = obj.get("name")
+        if not name:
+            continue
+        args = obj.get("arguments", {})
+        calls.append({"id": f"call_{uuid.uuid4().hex[:12]}", "type": "function",
+                      "function": {"name": name, "arguments": args if isinstance(args, str) else json.dumps(args)}})
+    if calls:
+        content = TOOL_CALL_TAG.sub("", content).strip()
+    return content, calls
+
+
+class Agent:
+    def __init__(self, client: api.Client, ui, root: Path, settings: Dict[str, Any],
+                 permissions: Permissions, model: str, *, session: Optional[SessionWriter] = None,
+                 is_subagent: bool = False, max_turns: Optional[int] = None):
+        self.client = client
+        self.ui = ui
+        self.root = root.resolve()
+        self.settings = settings
+        self.permissions = permissions
+        self.model = model
+        self.session = session
+        self.is_subagent = is_subagent
+        self.max_turns = max_turns
+        self.window = int(settings.get("contextWindow") or 32768)
+        self.max_output = int(settings.get("maxOutputTokens") or 8192)
+        self.tools = read_only_tools() if is_subagent else default_tools(settings)
+        self.tool_map = {t.name: t for t in self.tools}
+        self.tool_schemas = [t.schema() for t in self.tools]
+        self.shell_kind = detect_shell(settings.get("shell"))[0]
+        self.ctx = ToolContext(root=self.root, settings=settings, ui=ui, tracker=ReadTracker(), agent=self)
+        self.tokens = context.TokenTracker()
+        self.cancel = threading.Event()
+        self.pending_note: Optional[str] = None
+        self.memory_files: List[memory.MemoryFile] = []
+        self.on_usage: Optional[Callable[[], None]] = None
+        self.messages: List[Dict[str, Any]] = [{"role": "system", "content": self._build_system()}]
+
+    # ---------------------------------------------------------- prompt
+    def _build_system(self) -> str:
+        if self.is_subagent:
+            return prompts.build_system_prompt(self.root, self.shell_kind, "", subagent=True)
+        self.memory_files = memory.load(self.root)
+        return prompts.build_system_prompt(self.root, self.shell_kind, memory.render(self.memory_files))
+
+    def reload_system(self) -> None:
+        self.messages[0] = {"role": "system", "content": self._build_system()}
+
+    def load_history(self, messages: List[Dict[str, Any]], todos: Optional[List[Dict[str, Any]]] = None) -> None:
+        self.messages = [self.messages[0]] + [m for m in messages if m.get("role") != "system"]
+        if todos:
+            self.ctx.todos[:] = todos
+
+    def clear(self) -> None:
+        self.messages = [self.messages[0]]
+        self.ctx.todos.clear()
+        self.ctx.tracker = ReadTracker()
+        self.pending_note = None
+
+    def _append(self, msg: Dict[str, Any]) -> None:
+        self.messages.append(msg)
+        if self.session is not None:
+            self.session.message(msg)
+
+    # ---------------------------------------------------------- public
+    def run_turn(self, user_text: str, max_turns: Optional[int] = None) -> TurnResult:
+        max_turns = max_turns or self.max_turns
+        text = user_text
+        if self.pending_note:
+            text = self.pending_note + "\n\n" + text
+            self.pending_note = None
+        if len(self.messages) == 1 and not self.is_subagent:
+            text = prompts.dynamic_context(self.root, _branch(self.root)) + "\n\n" + text
+        self._append({"role": "user", "content": text})
+        self.cancel.clear()
+        turns = 0
+        last_text = ""
+        todos_before = list(self.ctx.todos)
+        while True:
+            if max_turns and turns >= max_turns:
+                return TurnResult(last_text, "max_turns", turns)
+            turns += 1
+            try:
+                self.maybe_compact()
+                resp = self._request()
+            except (Interrupted, KeyboardInterrupt):
+                self.ui.end_response()
+                self.ui.warn("Interrupted. Tell Euron Code what to do instead.")
+                self.pending_note = "[The user interrupted your previous response.]"
+                return TurnResult(last_text, "interrupted", turns)
+            except EuronError as e:
+                self.ui.end_response()
+                return TurnResult(last_text, "error", turns, error=e)
+            msg: Dict[str, Any] = {"role": "assistant", "content": resp.content}
+            if resp.tool_calls:
+                msg["tool_calls"] = resp.tool_calls
+            self._append(msg)
+            last_text = resp.content or last_text
+            if not resp.tool_calls:
+                if resp.finish_reason == "length":
+                    self.ui.warn("(The response hit the output limit.)")
+                if self.ctx.todos != todos_before and self.session is not None:
+                    self.session.todos(self.ctx.todos)
+                return TurnResult(resp.content, "end_turn", turns)
+            stop = self._run_tools(resp.tool_calls, truncated=(resp.finish_reason == "length"))
+            if self.ctx.todos != todos_before and self.session is not None:
+                self.session.todos(self.ctx.todos)
+                todos_before = list(self.ctx.todos)
+            if stop == DENIED:
+                return TurnResult(last_text, "denied", turns)
+            if stop == "interrupted":
+                self.ui.warn("Interrupted. Tell Euron Code what to do instead.")
+                self.pending_note = "[The user interrupted the previous tool call.]"
+                return TurnResult(last_text, "interrupted", turns)
+
+    # ---------------------------------------------------------- model request
+    def _payload(self) -> Dict[str, Any]:
+        est = self.tokens.prompt_estimate(self.messages, self.tool_schemas)
+        room = self.window - est - 256
+        max_tokens = max(1024, min(self.max_output, room))
+        return {
+            "model": self.model,
+            "messages": self.messages,
+            "tools": self.tool_schemas,
+            "tool_choice": "auto",
+            "max_tokens": max_tokens,
+        }
+
+    def _with_retries(self, call: Callable[[], Any], allow_compact: bool = True) -> Any:
+        busy = 0
+        rate = 0
+        net = 0
+        compacted = False
+        while True:
+            try:
+                return call()
+            except RateLimitedError as e:
+                rate += 1
+                if rate > MAX_RATE_LIMIT_RETRIES:
+                    raise
+                wait = e.retry_after if e.retry_after is not None else RATE_LIMIT_FALLBACK
+                self._wait(wait, "Rate limit reached (requests per minute).")
+            except BusyError as e:
+                if busy >= len(BUSY_BACKOFF):
+                    raise EuronError("Euron Code servers are still busy after 5 tries. Please try again in a few minutes.",
+                                     status=e.status, code=e.code)
+                wait = BUSY_BACKOFF[busy]
+                if e.code == "user_queue_full" and busy == 0:
+                    # we never overlap requests, so this is the gateway still releasing the
+                    # previous slot right after [DONE]: retry quickly the first time
+                    wait = 1
+                busy += 1
+                self._wait(wait, "Euron Code servers are busy, retrying...")
+            except ContextTooLongError:
+                if compacted or not allow_compact:
+                    raise
+                compacted = True
+                self.ui.warn("The conversation is too long for the model; compacting and retrying once.")
+                self.compact(force=True)
+            except NetworkError:
+                if net >= len(NETWORK_BACKOFF):
+                    raise
+                wait = NETWORK_BACKOFF[net]
+                net += 1
+                self._wait(wait, "Network problem talking to Euron Code.")
+
+    def _wait(self, seconds: float, message: str) -> None:
+        self.ui.end_response()
+        try:
+            self.ui.countdown(seconds, message, self.cancel)
+        except KeyboardInterrupt:
+            raise Interrupted()
+        if self.cancel.is_set():
+            raise Interrupted()
+
+    def _request(self) -> Response:
+        def call() -> Response:
+            payload = self._payload()
+            raw_est = context.estimate_tokens(self.messages, self.tool_schemas)
+            resp = self._stream_once(payload)
+            self.tokens.record(resp.usage, raw_est)
+            if self.on_usage:
+                self.on_usage()
+            return resp
+        return self._with_retries(call)
+
+    def _stream_once(self, payload: Dict[str, Any]) -> Response:
+        r = Response()
+        calls: Dict[int, Dict[str, Any]] = {}
+        shown = False
+        self.ui.begin_response()
+        started = time.monotonic()
+
+        def on_wait() -> None:
+            if not shown:
+                waited = time.monotonic() - started
+                if waited > 3:
+                    self.ui.waiting(f"Waiting for Euron Code... {waited:.0f}s (queued; Esc to cancel)")
+
+        interactive = getattr(self.ui, "interactive", False) and not self.is_subagent
+        try:
+            with EscWatcher(self.cancel, enabled=interactive):
+                stream = self.client.stream_chat(payload, cancel=self.cancel, on_wait=on_wait)
+                try:
+                    for chunk in stream:
+                        if self._consume(chunk, r, calls):
+                            shown = True
+                finally:
+                    stream.close()
+        except KeyboardInterrupt:
+            self.cancel.set()
+            self._keep_partial(r)
+            raise Interrupted()
+        except Interrupted:
+            self._keep_partial(r)
+            raise
+        except EuronError as e:
+            if shown and not isinstance(e, (api.NotEntitledError, api.AuthError, api.QuotaExceededError)):
+                self.ui.end_response()
+                raise MidStreamError(
+                    f"The response stopped part-way ({e.message}). Nothing more was applied. "
+                    "Send your message again to retry.", status=e.status, code=e.code) from None
+            raise
+        self.ui.end_response()
+        r.tool_calls = []
+        for idx in sorted(calls):
+            c = calls[idx]
+            if not c["function"]["name"]:
+                continue
+            if not c["id"]:
+                c["id"] = f"call_{uuid.uuid4().hex[:12]}"
+            r.tool_calls.append(c)
+        if not r.tool_calls and "<tool_call>" in r.content:
+            r.content, r.tool_calls = parse_inline_tool_calls(r.content)
+        return r
+
+    def _consume(self, chunk: Dict[str, Any], r: Response, calls: Dict[int, Dict[str, Any]]) -> bool:
+        """Apply one SSE chunk. Returns True when it carried visible output."""
+        shown = False
+        if chunk.get("usage"):
+            r.usage = chunk["usage"]
+        for choice in chunk.get("choices") or []:
+            delta = choice.get("delta") or {}
+            reasoning = delta.get("reasoning") or delta.get("reasoning_content")
+            if reasoning:
+                shown = True
+                r.reasoning_chars += len(reasoning)
+                self.ui.reasoning(reasoning)
+            text = delta.get("content")
+            if text:
+                shown = True
+                r.content += text
+                self.ui.content(text)
+            for tc in delta.get("tool_calls") or []:
+                shown = True
+                idx = tc.get("index", len(calls))
+                cur = calls.setdefault(idx, {"id": None, "type": "function",
+                                             "function": {"name": "", "arguments": ""}})
+                if tc.get("id"):
+                    cur["id"] = tc["id"]
+                fn = tc.get("function") or {}
+                if fn.get("name"):
+                    cur["function"]["name"] += fn["name"]
+                    self.ui.tool_call_pending(cur["function"]["name"])
+                if fn.get("arguments"):
+                    cur["function"]["arguments"] += fn["arguments"]
+            if choice.get("finish_reason"):
+                r.finish_reason = choice["finish_reason"]
+        return shown
+
+    def _keep_partial(self, r: Response) -> None:
+        """Keep the visible part of an interrupted answer so the model knows what it said."""
+        self.ui.end_response()
+        if r.content.strip():
+            self._append({"role": "assistant", "content": r.content + "\n[interrupted by the user]"})
+
+    # ---------------------------------------------------------- tools
+    def _run_tools(self, tool_calls: List[Dict[str, Any]], truncated: bool = False) -> Optional[str]:
+        stop: Optional[str] = None
+        for i, tc in enumerate(tool_calls):
+            if stop is not None:
+                self._append({"role": "tool", "tool_call_id": tc["id"], "name": tc["function"]["name"],
+                              "content": "Skipped: the user stopped this turn before this tool ran."})
+                continue
+            try:
+                content, outcome = self._execute(tc, truncated)
+            except KeyboardInterrupt:
+                content, outcome = "Interrupted by the user (Ctrl-C).", "interrupted"
+            self._append({"role": "tool", "tool_call_id": tc["id"], "name": tc["function"]["name"],
+                          "content": content})
+            if outcome in (DENIED, "interrupted"):
+                stop = outcome
+        return stop
+
+    def _execute(self, tc: Dict[str, Any], truncated: bool):
+        name = tc["function"]["name"]
+        raw = tc["function"].get("arguments") or "{}"
+        tool = self.tool_map.get(name)
+        if tool is None:
+            self.ui.tool_start(name, "(unknown tool)")
+            return f"Error: unknown tool `{name}`. Available: {', '.join(self.tool_map)}.", None
+        try:
+            args = json.loads(raw) if raw.strip() else {}
+            if not isinstance(args, dict):
+                raise ValueError("arguments must be a JSON object")
+        except ValueError as e:
+            self.ui.tool_start(name, "(invalid arguments)")
+            hint = (" The output limit cut the call off; write smaller pieces (for example several edits)."
+                    if truncated else "")
+            return f"Error: invalid JSON arguments for {name}: {e}.{hint}", None
+        try:
+            summary = tool.describe(args, self.ctx)
+        except Exception:
+            summary = ""
+        self.ui.tool_start(name, summary)
+        try:
+            req = tool.permission(args, self.ctx)
+            decision = self.permissions.check(req)
+            if decision == "deny":
+                msg = "Permission denied by a deny rule in settings. Do not retry this action."
+                self.ui.tool_result(msg, is_error=True)
+                return "Error: " + msg, None
+            if decision == "ask":
+                verdict, feedback = self._ask(tool, args, req)
+                if verdict != "allow":
+                    note = "The user denied this action."
+                    if feedback:
+                        note += f" The user said: {feedback}"
+                        self.ui.tool_result("denied", is_error=True)
+                        return note, None  # continue the loop with the feedback
+                    self.ui.tool_result("denied", is_error=True)
+                    if not getattr(self.ui, "interactive", True):
+                        return note + " Do not retry it; continue without it or explain what you need.", None
+                    return note + " Wait for the user's next instruction.", DENIED
+            elif req.category == "Edit":
+                self.ui.show_diff(tool.preview(args, self.ctx) or "")
+            result = tool.run(args, self.ctx)
+        except ToolError as e:
+            result = ToolResult(str(e), is_error=True)
+        except KeyboardInterrupt:
+            raise
+        except Exception as e:  # a tool bug must not kill the session
+            result = ToolResult(f"Tool {name} failed unexpectedly: {type(e).__name__}: {e}", is_error=True)
+        if name != "todo_write":
+            self.ui.tool_result(result.preview if result.preview is not None else result.content, result.is_error)
+        content = result.content
+        if result.is_error and not content.startswith(("Error", "Exit code")):
+            content = "Error: " + content
+        return content, None
+
+    def _ask(self, tool, args, req: Request):
+        detail = tool.preview(args, self.ctx)  # may raise ToolError (e.g. edit does not match)
+        if req.category == "Edit":
+            self.ui.show_diff(detail or "")
+            detail = None
+        titles = {
+            "Edit": "Apply this change?",
+            "Bash": "Run this command?",
+            "WebFetch": f"Fetch from {req.domain}?",
+            "DbWrite": "Run this WRITE statement on the database?",
+            "Read": "Read outside the project (or a secret-looking file)?",
+            "Db": "Open this database outside the project?",
+        }
+        title = titles.get(req.category or "", f"Allow {tool.name}?")
+        options = [("y", "yes"), ("n", "no")]
+        if req.category == "Bash":
+            from euron_code.permissions import command_prefix
+            options.append(("a", "always this exact command (session)"))
+            options.append(("p", f"always `{command_prefix(req.command or '')}` commands (session)"))
+        elif req.category != "DbWrite":
+            options.append(("a", f"always allow {req.category} (session)"))
+        if req.category not in ("DbWrite",):
+            options.append(("s", "always, and save to .euron/settings.local.json"))
+        choice = self.ui.ask_permission(title, detail, options)
+        if choice == "y":
+            return "allow", None
+        if choice in ("a", "p", "s"):
+            rule = self.permissions.session_rule_for(req, prefix=(choice == "p" or (choice == "s" and req.category == "Bash")))
+            self.permissions.grant_session(rule)
+            if choice == "s":
+                from euron_code import config
+                path = config.add_permission_rule(self.root, "allow", rule)
+                self.ui.dim(f"  saved allow rule {rule} to {path}")
+            return "allow", None
+        feedback = ""
+        if getattr(self.ui, "interactive", False):
+            feedback = self.ui.ask_text("  Tell Euron Code what to do instead (Enter to stop): ").strip()
+        return "deny", feedback or None
+
+    # ---------------------------------------------------------- compaction
+    def context_usage(self) -> int:
+        return self.tokens.prompt_estimate(self.messages, self.tool_schemas)
+
+    def maybe_compact(self) -> None:
+        if not self.settings.get("autoCompact", True):
+            return
+        threshold = float(self.settings.get("compactThreshold") or 0.75) * self.window
+        if self.context_usage() > threshold:
+            self.ui.dim(f"Context is {self.context_usage() * 100 // self.window}% full; compacting...")
+            self.compact()
+
+    def compact(self, force: bool = False, instructions: Optional[str] = None, manual: bool = False) -> bool:
+        threshold = float(self.settings.get("compactThreshold") or 0.75) * self.window
+        target = threshold * 0.6
+        before = self.context_usage()
+        # stage 1: drop bulky old tool outputs
+        if not manual:
+            context.elide_old_tool_outputs(self.messages, keep_last=4)
+            if self.context_usage() <= target and not force:
+                self.ctx.tracker.clear()
+                self._persist_compaction()
+                self.ui.dim(f"Compacted: removed old tool outputs ({before} -> {self.context_usage()} tokens est.).")
+                return True
+        users = [i for i, m in enumerate(self.messages) if m.get("role") == "user"]
+        if manual and len(users) > 1:
+            cut = users[-1]  # /compact: summarise everything before the latest exchange
+        else:
+            _, cut = context.split_for_compaction(self.messages, int(self.window * 0.2))
+        if cut <= 1:
+            if not manual:
+                context.elide_old_tool_outputs(self.messages, keep_last=1, min_chars=300)
+                self._persist_compaction()
+            self.ui.warn("Nothing older to summarise; the current turn alone is large. Consider /clear.")
+            return False
+        old = self.messages[1:cut]
+        recent = self.messages[cut:]
+        transcript = context.render_transcript(old)
+        max_in_chars = int((self.window - 3000) * context.CHARS_PER_TOKEN * 0.8)
+        if len(transcript) > max_in_chars:
+            transcript = transcript[-max_in_chars:]
+        ask = "Summarise this conversation so far.\n\n<transcript>\n" + transcript + "\n</transcript>"
+        if instructions:
+            ask += f"\n\nExtra instructions from the user for the summary: {instructions}"
+        payload = {"model": self.model, "max_tokens": 1500,
+                   "messages": [{"role": "system", "content": prompts.COMPACT}, {"role": "user", "content": ask}]}
+        self.ui.begin_response()
+        self.ui.waiting("Compacting conversation...")
+        try:
+            data = self._with_retries(lambda: self.client.chat(payload), allow_compact=False)
+        except EuronError as e:
+            self.ui.end_response()
+            self.ui.warn(f"Could not summarise the conversation ({e.message}); dropped old tool outputs instead.")
+            context.elide_old_tool_outputs(self.messages, keep_last=2, min_chars=300)
+            self._persist_compaction()
+            return False
+        self.ui.end_response()
+        self.tokens.record(data.get("usage"), 0)
+        summary = ""
+        try:
+            summary = (data["choices"][0]["message"].get("content") or "").strip()
+        except (KeyError, IndexError, TypeError):
+            pass
+        if not summary:
+            self.ui.warn("The summary came back empty; keeping the conversation as it was.")
+            return False
+        head = "[Summary of the earlier part of this conversation]\n" + summary
+        if self.ctx.todos:
+            head += "\n\nCurrent todo list:\n" + render_todos(self.ctx.todos)
+        last_user = next((m for m in reversed(old) if m.get("role") == "user"), None)
+        if recent[0].get("role") == "user":
+            first = dict(recent[0])
+            first["content"] = head + "\n\n[Latest message]\n" + str(first.get("content") or "")
+            self.messages = [self.messages[0], first] + recent[1:]
+        else:
+            # cut inside the current turn: restate the user's request, then continue the work
+            if last_user is not None:
+                req = str(last_user.get("content") or "")
+                if len(req) > 4000:
+                    req = req[:4000] + "\n[... request truncated ...]"
+                head += "\n\n[The user's current request, verbatim]\n" + req
+            head += "\n\nContinue the task from where the work below left off."
+            self.messages = [self.messages[0], {"role": "user", "content": head}] + recent
+        self.ctx.tracker.clear()
+        self.tokens.ratio = 1.0
+        self._persist_compaction()
+        self.ui.dim(f"Compacted: {before} -> {self.context_usage()} tokens (estimated).")
+        return True
+
+    def _persist_compaction(self) -> None:
+        if self.session is not None:
+            self.session.compact(self.messages[1:])
+
+    # ---------------------------------------------------------- sub-agent
+    def run_subagent(self, prompt: str) -> str:
+        sub_ui = _SubagentUI(self.ui)
+        sub = Agent(self.client, sub_ui, self.root, self.settings, self.permissions, self.model,
+                    is_subagent=True, max_turns=15)
+        sub.cancel = self.cancel
+        res = sub.run_turn(prompt)
+        self.tokens.session_prompt += sub.tokens.session_prompt
+        self.tokens.session_completion += sub.tokens.session_completion
+        self.tokens.requests += sub.tokens.requests
+        if res.error is not None:
+            raise ToolError(f"Sub-agent failed: {res.error.message}")
+        if res.stop_reason == "interrupted":
+            raise KeyboardInterrupt()
+        text = res.text.strip() or "(the sub-agent returned no answer)"
+        if res.stop_reason == "max_turns":
+            text += "\n[sub-agent stopped at its step limit]"
+        return text
+
+
+class _SubagentUI:
+    """Indented, compact progress for sub-agent tool calls."""
+
+    interactive = False
+
+    def __init__(self, parent):
+        self.parent = parent
+
+    def __getattr__(self, name):
+        return lambda *a, **k: None
+
+    def tool_start(self, name, summary):
+        self.parent.dim(f"    - {name} {summary}")
+
+    def countdown(self, seconds, message, cancel=None):
+        self.parent.countdown(seconds, message, cancel)
+
+    def warn(self, msg):
+        self.parent.warn("    " + msg)
+
+    def ask_permission(self, *a, **k):
+        return "n"
+
+
+def _branch(root: Path) -> Optional[str]:
+    from euron_code.config import git_branch
+    return git_branch(root)