euron-code 0.1.0__py3-none-any.whl

euron_code/tools/shell.py

@@ -0,0 +1,214 @@
+"""bash / run_command: runs a shell command with a persistent working directory.
+
+Windows uses PowerShell (pwsh if installed, else Windows PowerShell 5.1), falling back to cmd.
+macOS / Linux use $SHELL when it is bash or zsh, else bash, else sh.
+"""
+
+from __future__ import annotations
+
+import base64
+import os
+import shutil
+import signal
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+from euron_code.permissions import Request
+from euron_code.tools.base import Tool, ToolError, ToolResult, opt_int, require, truncate
+
+MARK = "__EURON_CWD__"
+
+
+def detect_shell(preference: Optional[str] = None) -> Tuple[str, str]:
+    """Return (kind, executable). kind: bash | sh | zsh | powershell | cmd."""
+    pref = (preference or "").strip()
+    if pref:
+        exe = shutil.which(pref) or pref
+        low = Path(exe).name.lower()
+        if "pwsh" in low or "powershell" in low:
+            return "powershell", exe
+        if low.startswith("cmd"):
+            return "cmd", exe
+        if "zsh" in low:
+            return "zsh", exe
+        if "bash" in low:
+            return "bash", exe
+        return "sh", exe
+    if os.name == "nt":
+        for cand in ("pwsh", "powershell"):
+            exe = shutil.which(cand)
+            if exe:
+                return "powershell", exe
+        sysroot = os.environ.get("SystemRoot") or os.environ.get("SYSTEMROOT") or r"C:\Windows"
+        builtin = Path(sysroot) / "System32" / "WindowsPowerShell" / "v1.0" / "powershell.exe"
+        if builtin.is_file():
+            return "powershell", str(builtin)
+        return "cmd", os.environ.get("COMSPEC") or str(Path(sysroot) / "System32" / "cmd.exe")
+    sh = os.environ.get("SHELL", "")
+    if sh and Path(sh).name in ("bash", "zsh") and os.path.exists(sh):
+        return Path(sh).name, sh
+    exe = shutil.which("bash")
+    if exe:
+        return "bash", exe
+    return "sh", shutil.which("sh") or "/bin/sh"
+
+
+def build_argv(kind: str, exe: str, command: str):
+    """Return the argv list (or, for cmd.exe, a raw command line string)."""
+    if kind == "powershell":
+        script = (
+            "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8\n"
+            "$OutputEncoding = [System.Text.Encoding]::UTF8\n"
+            "$ProgressPreference = 'SilentlyContinue'\n"
+            "$global:LASTEXITCODE = 0\n"
+            f"{command}\n"
+            "$__euron_ok = $?\n"
+            "$__euron_ec = if ($global:LASTEXITCODE -ne 0) { $global:LASTEXITCODE } elseif ($__euron_ok) { 0 } else { 1 }\n"
+            f"[Console]::Out.Write(\"`n{MARK}\" + (Get-Location).ProviderPath + \"`n\")\n"
+            "exit $__euron_ec\n"
+        )
+        enc = base64.b64encode(script.encode("utf-16-le")).decode("ascii")
+        return [exe, "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand", enc]
+    if kind == "cmd":
+        # delayed expansion so ERRORLEVEL/CD are read after the command runs
+        # a raw string: list2cmdline's backslash-escaping confuses cmd.exe. /s strips the outer quotes.
+        script = f"{command} & set __EURON_EC=!ERRORLEVEL! & echo.{MARK}!CD! & exit /b !__EURON_EC!"
+        return f'"{exe}" /d /v:on /s /c "{script}"'
+
+    # Git Bash / MSYS on Windows: `pwd -W` prints a C:/... path Python can use
+    pwd = "pwd -W 2>/dev/null || pwd" if os.name == "nt" else "pwd"
+    script = (
+        f"{command}\n"
+        "__euron_ec=$?\n"
+        f"printf '\\n{MARK}%s\\n' \"$({pwd})\"\n"
+        "exit $__euron_ec\n"
+    )
+    return [exe, "-c", script]
+
+
+def _kill_tree(proc: subprocess.Popen) -> None:
+    try:
+        if os.name == "nt":
+            subprocess.run(["taskkill", "/F", "/T", "/PID", str(proc.pid)],
+                           capture_output=True, timeout=10)
+        else:
+            os.killpg(proc.pid, signal.SIGKILL)
+    except Exception:
+        try:
+            proc.kill()
+        except Exception:
+            pass
+
+
+class ShellSession:
+    def __init__(self, root: Path, preference: Optional[str] = None):
+        self.root = root
+        self.cwd = root
+        self.kind, self.exe = detect_shell(preference)
+
+    def run(self, command: str, timeout: float) -> Tuple[int, str, bool]:
+        """Return (exit_code, output, timed_out). Raises KeyboardInterrupt after killing the child."""
+        argv = build_argv(self.kind, self.exe, command)
+        env = dict(os.environ)
+        env.setdefault("PAGER", "cat")
+        env.setdefault("GIT_PAGER", "cat")
+        env["EURON_CODE"] = "1"
+        kw = {}
+        if os.name == "nt":
+            kw["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP  # type: ignore[attr-defined]
+        else:
+            kw["start_new_session"] = True
+        cwd = self.cwd if self.cwd.is_dir() else self.root
+        proc = subprocess.Popen(argv, cwd=str(cwd), stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
+                                stderr=subprocess.STDOUT, env=env, **kw)
+        timed_out = False
+        try:
+            out, _ = proc.communicate(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            timed_out = True
+            _kill_tree(proc)
+            try:
+                out, _ = proc.communicate(timeout=5)
+            except Exception:
+                out = b""
+        except KeyboardInterrupt:
+            _kill_tree(proc)
+            raise
+        text = (out or b"").decode("utf-8", errors="replace").replace("\r\n", "\n")
+        code = proc.returncode if proc.returncode is not None else -1
+        idx = text.rfind(MARK)
+        if idx != -1:
+            line_end = text.find("\n", idx)
+            new_cwd = text[idx + len(MARK): line_end if line_end != -1 else None].strip()
+            text = text[:idx].rstrip("\n") + (text[line_end + 1:] if line_end != -1 else "")
+            if new_cwd and Path(new_cwd).is_dir():
+                self.cwd = Path(new_cwd)
+        if code < 0 and os.name != "nt" and not timed_out:
+            code = 128 + abs(code)
+        return code, text.rstrip(), timed_out
+
+
+class Bash(Tool):
+    name = "bash"
+    description = (
+        "Run a shell command on the user's machine and return its output and exit code. The working "
+        "directory persists between calls (a `cd` carries over). Use for tests, builds, git and package "
+        "commands. Do not use it to read or edit files (use read_file/edit_file) or to search (use "
+        "grep/glob). Do not start servers or watchers that never exit; they are killed at the timeout."
+    )
+    parameters = {
+        "type": "object",
+        "properties": {
+            "command": {"type": "string", "description": "The command to run."},
+            "timeout": {"type": "integer", "description": "Seconds before the command is killed (default 120, max 600)."},
+            "description": {"type": "string", "description": "5-10 words on what the command does."},
+        },
+        "required": ["command"],
+    }
+
+    def _session(self, ctx) -> ShellSession:
+        if ctx.shell is None:
+            ctx.shell = ShellSession(ctx.root, ctx.settings.get("shell"))
+        return ctx.shell
+
+    def permission(self, args, ctx):
+        return Request("Bash", self.name, command=require(args, "command").strip())
+
+    def describe(self, args, ctx):
+        return args.get("command", "").strip().splitlines()[0][:160] if args.get("command") else ""
+
+    def preview(self, args, ctx):
+        sh = self._session(ctx)
+        cmd = require(args, "command")
+        where = ctx.rel(sh.cwd)
+        return f"$ {cmd}\n(in {where or '.'}, shell: {sh.kind})"
+
+    def run(self, args, ctx):
+        cmd = require(args, "command").strip()
+        if not cmd:
+            raise ToolError("Empty command.")
+        default_t = int(ctx.settings.get("bashTimeout") or 120)
+        timeout = max(1, min(opt_int(args, "timeout", default_t) or default_t, 600))
+        sh = self._session(ctx)
+        before = sh.cwd
+        try:
+            code, out, timed_out = sh.run(cmd, timeout)
+        except FileNotFoundError as e:
+            raise ToolError(f"Shell not found: {e}")
+        except KeyboardInterrupt:
+            return ToolResult("The user interrupted the command (Ctrl-C); it was killed.", is_error=True,
+                              preview="interrupted")
+        body = truncate(out, ctx.max_output_chars, "pipe through a filter such as `| tail -50` for less")
+        head = f"Exit code: {code}"
+        if timed_out:
+            head += f" (killed after {timeout}s timeout)"
+        if sh.cwd != before:
+            head += f"\nWorking directory is now: {ctx.rel(sh.cwd)}"
+        content = head + ("\n" + body if body else "\n(no output)")
+        return ToolResult(content, is_error=(code != 0), preview=(body or "(no output)") + f"\n[exit {code}]")
+
+
+def python_executable() -> str:
+    return sys.executable

euron_code/tools/task.py

@@ -0,0 +1,41 @@
+"""task: a read-only sub-agent with its own context window.
+
+The sub-agent runs sequentially (never in parallel with the main agent: the gateway allows one
+generation per user), sees only read-only tools, and returns its final answer as the tool result.
+Useful for broad searches whose file dumps would otherwise fill the main context.
+"""
+
+from __future__ import annotations
+
+from euron_code.tools.base import Tool, ToolError, ToolResult, require, truncate
+
+
+class Task(Tool):
+    name = "task"
+    read_only = True
+    description = (
+        "Delegate a self-contained research question to a sub-agent with a fresh context and READ-ONLY "
+        "tools (read_file, list_dir, glob, grep). It cannot edit files or run commands. Use it for broad "
+        "searches (\"where is X handled?\", \"summarise how module Y works\") so the file contents do not "
+        "fill your own context. Give it a complete, specific prompt; it returns a concise report."
+    )
+    parameters = {
+        "type": "object",
+        "properties": {
+            "description": {"type": "string", "description": "3-5 word label."},
+            "prompt": {"type": "string", "description": "The full task for the sub-agent."},
+        },
+        "required": ["prompt"],
+    }
+
+    def describe(self, args, ctx):
+        return args.get("description") or (args.get("prompt") or "")[:80]
+
+    def run(self, args, ctx):
+        prompt = require(args, "prompt")
+        if ctx.agent is None:
+            raise ToolError("Sub-agents are not available here.")
+        if getattr(ctx.agent, "is_subagent", False):
+            raise ToolError("A sub-agent cannot start another sub-agent.")
+        report = ctx.agent.run_subagent(prompt)
+        return ToolResult(truncate(report, ctx.max_output_chars), preview=report[:300])

euron_code/tools/todo.py

@@ -0,0 +1,64 @@
+"""todo_write: the task list the model keeps for multi-step work (shown to the user)."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from euron_code.tools.base import Tool, ToolError, ToolResult
+
+STATUSES = ("pending", "in_progress", "completed")
+
+
+def render_todos(todos: List[Dict[str, Any]]) -> str:
+    if not todos:
+        return "(no todos)"
+    mark = {"completed": "[x]", "in_progress": "[~]", "pending": "[ ]"}
+    return "\n".join(f"{mark.get(t['status'], '[ ]')} {t['content']}" for t in todos)
+
+
+class TodoWrite(Tool):
+    name = "todo_write"
+    read_only = True
+    description = (
+        "Create or update your task list for multi-step work. Send the WHOLE list each time. "
+        "Keep exactly one item in_progress while working; mark items completed as soon as they are done. "
+        "Skip this for trivial one-step requests."
+    )
+    parameters = {
+        "type": "object",
+        "properties": {
+            "todos": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "content": {"type": "string"},
+                        "status": {"type": "string", "enum": list(STATUSES)},
+                    },
+                    "required": ["content", "status"],
+                },
+            }
+        },
+        "required": ["todos"],
+    }
+
+    def describe(self, args, ctx):
+        todos = args.get("todos") or []
+        done = sum(1 for t in todos if isinstance(t, dict) and t.get("status") == "completed")
+        return f"{done}/{len(todos)} done"
+
+    def run(self, args, ctx):
+        todos = args.get("todos")
+        if not isinstance(todos, list):
+            raise ToolError("`todos` must be a list.")
+        clean = []
+        for i, t in enumerate(todos, 1):
+            if not isinstance(t, dict) or not str(t.get("content", "")).strip():
+                raise ToolError(f"todo {i} needs a non-empty `content`.")
+            st = t.get("status", "pending")
+            if st not in STATUSES:
+                raise ToolError(f"todo {i} has invalid status {st!r}; use {', '.join(STATUSES)}.")
+            clean.append({"content": str(t["content"]).strip(), "status": st})
+        ctx.todos[:] = clean
+        ctx.ui.show_todos(clean)
+        return ToolResult("Todo list updated:\n" + render_todos(clean), preview="")

euron_code/tools/web.py

@@ -0,0 +1,112 @@
+"""web_fetch: fetch a URL and return readable text (no JavaScript, no binaries)."""
+
+from __future__ import annotations
+
+import html
+import re
+from html.parser import HTMLParser
+from typing import List
+from urllib.parse import urlparse
+
+import httpx
+
+from euron_code import api
+from euron_code.permissions import Request
+from euron_code.tools.base import Tool, ToolError, ToolResult, require, truncate
+
+SKIP_TAGS = {"script", "style", "noscript", "svg", "head", "template", "iframe"}
+BLOCK_TAGS = {"p", "div", "br", "li", "tr", "h1", "h2", "h3", "h4", "h5", "h6", "pre", "section",
+              "article", "header", "footer", "table", "ul", "ol", "blockquote", "hr"}
+
+
+class _TextExtractor(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.parts: List[str] = []
+        self.skip = 0
+
+    def handle_starttag(self, tag, attrs):
+        if tag in SKIP_TAGS:
+            self.skip += 1
+        elif tag in BLOCK_TAGS:
+            self.parts.append("\n")
+        if tag == "a":
+            href = dict(attrs).get("href")
+            if href and href.startswith("http"):
+                self._href = href
+
+    def handle_endtag(self, tag):
+        if tag in SKIP_TAGS and self.skip:
+            self.skip -= 1
+        elif tag in BLOCK_TAGS:
+            self.parts.append("\n")
+
+    def handle_data(self, data):
+        if not self.skip:
+            self.parts.append(data)
+
+
+def html_to_text(src: str) -> str:
+    p = _TextExtractor()
+    try:
+        p.feed(src)
+        p.close()
+    except Exception:
+        return re.sub(r"<[^>]+>", " ", html.unescape(src))
+    text = "".join(p.parts)
+    text = re.sub(r"[ \t\r\f\v]+", " ", text)
+    text = re.sub(r"\n\s*\n+", "\n\n", text)
+    return text.strip()
+
+
+class WebFetch(Tool):
+    name = "web_fetch"
+    read_only = True
+    description = (
+        "Fetch an http(s) URL and return its text content (HTML is converted to plain text). "
+        "Use for documentation pages and API references. Asks the user before each new domain."
+    )
+    parameters = {
+        "type": "object",
+        "properties": {"url": {"type": "string"}},
+        "required": ["url"],
+    }
+
+    def permission(self, args, ctx):
+        url = require(args, "url")
+        return Request("WebFetch", self.name, domain=(urlparse(url).hostname or ""))
+
+    def describe(self, args, ctx):
+        return args.get("url", "")
+
+    def run(self, args, ctx):
+        url = require(args, "url").strip()
+        u = urlparse(url)
+        if u.scheme not in ("http", "https") or not u.hostname:
+            raise ToolError("Only http:// and https:// URLs are supported.")
+        host = u.hostname.lower()
+        try:
+            with httpx.Client(timeout=20.0, follow_redirects=False,
+                              headers={"User-Agent": api.user_agent()}) as c:
+                resp = c.get(url)
+                for _ in range(5):  # follow redirects only within the approved site
+                    if resp.status_code not in (301, 302, 303, 307, 308) or "location" not in resp.headers:
+                        break
+                    nxt = resp.url.join(resp.headers["location"])
+                    nh = (nxt.host or "").lower()
+                    if nh != host and not nh.endswith("." + host) and not host.endswith("." + nh):
+                        return ToolResult(f"{url} redirects to another site: {nxt}. Call web_fetch on that URL "
+                                          "if you need it (the user will be asked).", preview="redirect")
+                    resp = c.get(nxt)
+        except httpx.HTTPError as e:
+            raise ToolError(f"Fetch failed: {e}")
+        ctype = resp.headers.get("content-type", "")
+        if resp.status_code >= 400:
+            raise ToolError(f"HTTP {resp.status_code} from {url}")
+        if not any(t in ctype for t in ("text/", "json", "xml", "javascript")) and ctype:
+            raise ToolError(f"Not a text page (content-type {ctype}).")
+        body = resp.text
+        if "html" in ctype or body.lstrip()[:15].lower().startswith(("<!doctype", "<html")):
+            body = html_to_text(body)
+        header = f"URL: {resp.url}\nStatus: {resp.status_code}\n\n"
+        return ToolResult(header + truncate(body, ctx.max_output_chars), preview=f"{len(body)} chars")