euron-code 0.1.0__py3-none-any.whl

euron_code/credentials.py

@@ -0,0 +1,197 @@
+"""Credential storage: OS keyring when available, else ~/.euron/credentials.json (0600).
+
+Credentials are stored per API base URL, so logging in against a local test gateway
+never overwrites the real key.
+
+The API key is never printed in full: use `mask_key`.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from euron_code import config
+
+SERVICE = "euron-code"
+
+
+@dataclass
+class Credential:
+    api_key: str
+    base_url: str
+    user: Dict[str, Any] = field(default_factory=dict)
+
+    def to_json(self) -> Dict[str, Any]:
+        return {"apiKey": self.api_key, "baseUrl": self.base_url, "user": self.user}
+
+    @classmethod
+    def from_json(cls, d: Dict[str, Any]) -> "Credential":
+        return cls(api_key=d["apiKey"], base_url=d.get("baseUrl", ""), user=d.get("user") or {})
+
+
+def mask_key(key: Optional[str]) -> str:
+    if not key:
+        return "(none)"
+    if len(key) <= 12:
+        return key[:3] + "..."
+    return key[:7] + "..." + key[-4:]
+
+
+def credentials_file() -> Path:
+    return config.euron_home() / "credentials.json"
+
+
+def _store_mode() -> str:
+    env = os.environ.get("EURON_CREDENTIAL_STORE")
+    if env:
+        return env
+    return str(config.load_user_settings().get("credentialStore") or "auto")
+
+
+def _keyring():
+    """Return a usable keyring module or None."""
+    try:
+        import keyring  # type: ignore
+        from keyring.backends import fail  # type: ignore
+    except Exception:
+        return None
+    try:
+        kr = keyring.get_keyring()
+        if isinstance(kr, fail.Keyring):
+            return None
+        name = type(kr).__name__.lower()
+        if "null" in name or "fail" in name:
+            return None
+        # chainer with no usable backends also counts as unusable
+        if getattr(kr, "backends", None) == []:
+            return None
+    except Exception:
+        return None
+    return keyring
+
+
+def keyring_backend_name() -> str:
+    kr = _keyring()
+    if kr is None:
+        return "unavailable (using file)"
+    try:
+        k = kr.get_keyring()
+        return f"{type(k).__module__}.{type(k).__name__}"
+    except Exception:
+        return "unknown"
+
+
+# ---------------------------------------------------------------- file store
+
+def _read_file() -> Dict[str, Any]:
+    try:
+        with open(credentials_file(), "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return data if isinstance(data, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def _write_file(data: Dict[str, Any]) -> None:
+    path = credentials_file()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
+    fd = os.open(str(tmp), flags, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+    try:
+        os.chmod(tmp, stat.S_IRUSR | stat.S_IWUSR)
+    except OSError:
+        pass
+    os.replace(tmp, path)
+    try:
+        os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
+    except OSError:
+        pass
+
+
+# ---------------------------------------------------------------- public API
+
+def save(cred: Credential) -> str:
+    """Save and return the store used ('keyring' or 'file')."""
+    mode = _store_mode()
+    if mode in ("auto", "keyring"):
+        kr = _keyring()
+        if kr is not None:
+            try:
+                kr.set_password(SERVICE, cred.base_url, json.dumps(cred.to_json()))
+                # remove any stale file copy for this URL
+                data = _read_file()
+                if cred.base_url in data:
+                    data.pop(cred.base_url)
+                    _write_file(data)
+                return "keyring"
+            except Exception:
+                if mode == "keyring":
+                    raise
+    data = _read_file()
+    data[cred.base_url] = cred.to_json()
+    _write_file(data)
+    return "file"
+
+
+def load(base_url: Optional[str] = None) -> Optional[Credential]:
+    url = base_url or config.base_url()
+    env_key = os.environ.get("EURON_API_KEY")
+    if env_key:
+        return Credential(api_key=env_key, base_url=url, user={})
+    mode = _store_mode()
+    if mode in ("auto", "keyring"):
+        kr = _keyring()
+        if kr is not None:
+            try:
+                raw = kr.get_password(SERVICE, url)
+                if raw:
+                    return Credential.from_json(json.loads(raw))
+            except Exception:
+                pass
+    d = _read_file().get(url)
+    if isinstance(d, dict) and d.get("apiKey"):
+        return Credential.from_json(d)
+    return None
+
+
+def where(base_url: Optional[str] = None) -> str:
+    url = base_url or config.base_url()
+    if os.environ.get("EURON_API_KEY"):
+        return "env EURON_API_KEY"
+    kr = _keyring() if _store_mode() in ("auto", "keyring") else None
+    if kr is not None:
+        try:
+            if kr.get_password(SERVICE, url):
+                return "keyring"
+        except Exception:
+            pass
+    if url in _read_file():
+        return f"file {credentials_file()}"
+    return "none"
+
+
+def delete(base_url: Optional[str] = None) -> bool:
+    url = base_url or config.base_url()
+    removed = False
+    kr = _keyring()
+    if kr is not None:
+        try:
+            if kr.get_password(SERVICE, url):
+                kr.delete_password(SERVICE, url)
+                removed = True
+        except Exception:
+            pass
+    data = _read_file()
+    if url in data:
+        data.pop(url)
+        _write_file(data)
+        removed = True
+    return removed

euron_code/doctor.py

@@ -0,0 +1,88 @@
+"""`euron doctor`: check the local setup and the connection to Euron Code."""
+
+from __future__ import annotations
+
+import os
+import platform
+import sys
+from typing import List, Tuple
+
+import httpx
+from rich.markup import escape
+
+from euron_code import __version__, api, config, credentials
+from euron_code.tools.search import ripgrep_path
+from euron_code.tools.shell import detect_shell
+
+OK, WARN, FAIL = "ok", "warn", "fail"
+
+
+def run_checks() -> List[Tuple[str, str, str]]:
+    checks: List[Tuple[str, str, str]] = []
+    v = sys.version_info
+    checks.append(("Python", OK if v >= (3, 9) else FAIL,
+                   f"{platform.python_version()} ({sys.executable})"))
+    checks.append(("euron-code", OK, __version__))
+    checks.append(("Platform", OK, f"{platform.system()} {platform.release()} {platform.machine()}"))
+    url = config.base_url()
+    src = "EURON_CODE_API" if os.environ.get("EURON_CODE_API") else "default"
+    checks.append(("API base URL", OK, f"{url} ({src})"))
+
+    # connectivity: any HTTP answer means the gateway is reachable
+    try:
+        r = httpx.get(url + "/v1/models", timeout=10.0, headers={"User-Agent": api.user_agent()})
+        checks.append(("Connectivity", OK, f"reachable (HTTP {r.status_code})"))
+        reachable = True
+    except httpx.HTTPError as e:
+        checks.append(("Connectivity", FAIL, f"cannot reach {url}: {type(e).__name__}"))
+        reachable = False
+
+    cred = credentials.load(url)
+    if cred is None:
+        checks.append(("Login", WARN, "not logged in; run `euron login`"))
+    else:
+        checks.append(("Login", OK, f"key {credentials.mask_key(cred.api_key)} in {credentials.where(url)}"))
+        if reachable:
+            c = api.Client(api_key=cred.api_key, base_url=url)
+            try:
+                me = c.me(use_cache=False)
+                access = me.get("access") or {}
+                if access.get("entitled"):
+                    q = me.get("quota") or {}
+                    checks.append(("Entitlement", OK, f"{api.plan_label(access)}; "
+                                   f"{q.get('remainingToday', '?'):,} tokens left today"
+                                   if isinstance(q.get("remainingToday"), int) else api.plan_label(access)))
+                else:
+                    checks.append(("Entitlement", FAIL, api.NO_PLUS_MESSAGE))
+            except api.AuthError:
+                checks.append(("Entitlement", FAIL, "the saved key was rejected (401); run `euron login`"))
+            except api.EuronError as e:
+                checks.append(("Entitlement", WARN, f"could not check: {e.message}"))
+            finally:
+                c.close()
+
+    rg = ripgrep_path()
+    checks.append(("ripgrep", OK if rg else WARN, rg or "not found; grep uses the slower Python fallback"))
+    checks.append(("Keyring", OK if "unavailable" not in credentials.keyring_backend_name() else WARN,
+                   credentials.keyring_backend_name()))
+    kind, exe = detect_shell(config.load_user_settings().get("shell"))
+    checks.append(("Shell", OK, f"{kind} ({exe})"))
+    term = os.environ.get("TERM_PROGRAM") or os.environ.get("TERM") or ("Windows console" if os.name == "nt" else "?")
+    checks.append(("Terminal", OK if sys.stdout.isatty() else WARN,
+                   f"{term}{'' if sys.stdout.isatty() else ' (output is not a terminal)'}"))
+    checks.append(("Config", OK, f"{config.user_settings_path()}"))
+    return checks
+
+
+def doctor(ui) -> int:
+    checks = run_checks()
+    style = {OK: "[green]OK  [/green]", WARN: "[yellow]WARN[/yellow]", FAIL: "[red]FAIL[/red]"}
+    for name, st, detail in checks:
+        ui.info(f"{style[st]} {name:<14} {escape(detail)}")
+    fails = [c for c in checks if c[1] == FAIL]
+    ui.info("")
+    if fails:
+        ui.info(f"[red]{len(fails)} problem(s) found.[/red]")
+        return 1
+    ui.info("[green]All checks passed.[/green]")
+    return 0

euron_code/keys.py

@@ -0,0 +1,92 @@
+"""Esc-to-interrupt while the model is generating.
+
+A background thread watches the keyboard (msvcrt on Windows, cbreak termios elsewhere) and sets
+an Event when Esc is pressed. Ctrl-C works everywhere as well (KeyboardInterrupt).
+It is only active during streaming, never while a prompt is reading input.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import threading
+import time
+from typing import Optional
+
+
+class EscWatcher:
+    def __init__(self, event: threading.Event, enabled: bool = True):
+        self.event = event
+        self.enabled = enabled and _stdin_is_tty()
+        self._stop = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+        self._old_term = None
+
+    def __enter__(self) -> "EscWatcher":
+        if not self.enabled:
+            return self
+        try:
+            if os.name != "nt":
+                import termios
+                import tty
+                fd = sys.stdin.fileno()
+                self._old_term = termios.tcgetattr(fd)
+                tty.setcbreak(fd)
+        except Exception:
+            self._old_term = None
+            self.enabled = False
+            return self
+        self._thread = threading.Thread(target=self._run, name="euron-esc", daemon=True)
+        self._thread.start()
+        return self
+
+    def _run(self) -> None:
+        if os.name == "nt":
+            import msvcrt
+            while not self._stop.is_set():
+                try:
+                    if msvcrt.kbhit():
+                        ch = msvcrt.getwch()
+                        if ch == "\x1b":
+                            self.event.set()
+                            return
+                        if ch in ("\x00", "\xe0"):  # function/arrow key prefix: swallow
+                            msvcrt.getwch()
+                except Exception:
+                    return
+                time.sleep(0.05)
+        else:
+            import select
+            fd = sys.stdin.fileno()
+            while not self._stop.is_set():
+                try:
+                    r, _, _ = select.select([fd], [], [], 0.05)
+                    if r:
+                        ch = os.read(fd, 1)
+                        if ch == b"\x1b":
+                            # a lone Esc, not the start of an arrow-key sequence
+                            r2, _, _ = select.select([fd], [], [], 0.03)
+                            if not r2:
+                                self.event.set()
+                                return
+                            os.read(fd, 8)
+                except Exception:
+                    return
+
+    def __exit__(self, *exc) -> None:
+        self._stop.set()
+        if self._thread is not None:
+            self._thread.join(timeout=0.5)
+        if self._old_term is not None:
+            try:
+                import termios
+                termios.tcsetattr(sys.stdin.fileno(), termios.TCSADRAIN, self._old_term)
+            except Exception:
+                pass
+
+
+def _stdin_is_tty() -> bool:
+    try:
+        return sys.stdin.isatty() and sys.stdout.isatty()
+    except (AttributeError, ValueError):
+        return False

euron_code/memory.py

@@ -0,0 +1,97 @@
+"""EURON.md memory files.
+
+Loaded (in this order) into the system prompt:
+  1. ~/.euron/EURON.md                      (user memory, all projects)
+  2. EURON.md in each parent directory from the git root down to the project root
+  3. <project>/EURON.md                     (project memory, usually committed)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional
+
+from euron_code import config
+
+FILENAME = "EURON.md"
+MAX_MEMORY_CHARS = 12000  # keep memory from eating the 32k window
+
+
+@dataclass
+class MemoryFile:
+    path: Path
+    scope: str  # user | parent | project
+    text: str
+
+
+def memory_paths(root: Path) -> List[tuple]:
+    root = root.resolve()
+    out = [(config.euron_home() / FILENAME, "user")]
+    git_root = config.find_git_root(root)
+    if git_root is not None and git_root != root:
+        chain = []
+        cur = root.parent
+        while True:
+            chain.append(cur)
+            if cur == git_root or cur == cur.parent:
+                break
+            cur = cur.parent
+        for d in reversed(chain):
+            out.append((d / FILENAME, "parent"))
+    out.append((root / FILENAME, "project"))
+    return out
+
+
+def load(root: Path) -> List[MemoryFile]:
+    files = []
+    for p, scope in memory_paths(root):
+        try:
+            text = p.read_text(encoding="utf-8", errors="replace").strip()
+        except OSError:
+            continue
+        if text:
+            files.append(MemoryFile(p, scope, text))
+    return files
+
+
+def render(files: List[MemoryFile]) -> str:
+    if not files:
+        return ""
+    parts = []
+    budget = MAX_MEMORY_CHARS
+    for f in files:
+        text = f.text
+        if len(text) > budget:
+            text = text[:budget] + "\n[... memory file truncated ...]"
+        budget -= len(text)
+        parts.append(f"<memory scope=\"{f.scope}\" path=\"{f.path.as_posix()}\">\n{text}\n</memory>")
+        if budget <= 0:
+            break
+    return "\n\n".join(parts)
+
+
+def project_file(root: Path) -> Path:
+    return root.resolve() / FILENAME
+
+
+def user_file() -> Path:
+    return config.euron_home() / FILENAME
+
+
+def append_note(note: str, root: Path, scope: str = "project") -> Path:
+    path = user_file() if scope == "user" else project_file(root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    existing: Optional[str] = None
+    try:
+        existing = path.read_text(encoding="utf-8")
+    except OSError:
+        existing = None
+    note = note.strip()
+    with open(path, "a", encoding="utf-8", newline="") as f:
+        if existing is None or not existing.strip():
+            f.write("# Notes for Euron Code\n\n")
+        elif not existing.endswith("\n"):
+            f.write("\n")
+        f.write(f"- {note}\n")
+    return path