euron-code 0.1.0__py3-none-any.whl

euron_code/ui.py

@@ -0,0 +1,269 @@
+"""Terminal rendering. All output goes through a rich Console so Windows consoles,
+VS Code's terminal and pipes all behave (rich strips ANSI when not a terminal)."""
+
+from __future__ import annotations
+
+import sys
+import threading
+import time
+from typing import Any, Dict, List, Optional
+
+from rich.console import Console
+from rich.markup import escape
+from rich.text import Text
+
+
+class UI:
+    """Interactive UI. Subclassed by QuietUI for `euron -p`."""
+
+    interactive = True
+
+    def __init__(self, reasoning: str = "collapse", stderr: bool = False):
+        self.console = Console(stderr=stderr, highlight=False, soft_wrap=True)
+        self.reasoning_mode = reasoning
+        self._status = None
+        self._think_start: Optional[float] = None
+        self._think_chars = 0
+        self._content_started = False
+        self._reasoning_printed = False
+
+    # ---------------------------------------------------------- basic messages
+    def info(self, msg: str) -> None:
+        self.console.print(msg)
+
+    def dim(self, msg: str) -> None:
+        self.console.print(Text(msg, style="dim"))
+
+    def warn(self, msg: str) -> None:
+        self.console.print(Text(msg, style="yellow"))
+
+    def error(self, msg: str) -> None:
+        self.console.print(Text(msg, style="bold red"))
+
+    def plain(self, msg: str) -> None:
+        self.console.print(Text(msg))
+
+    def exact(self, msg: str) -> None:
+        """Print a message byte-for-byte (no wrapping, no markup), e.g. the no-Plus message."""
+        stream = sys.stderr if self.console.stderr else sys.stdout
+        stream.write(msg + "\n")
+        stream.flush()
+
+    # ---------------------------------------------------------- streaming
+    def _status_start(self, msg: str) -> None:
+        if self._status is None and self.console.is_terminal:
+            self._status = self.console.status(msg, spinner="dots")
+            self._status.start()
+        elif self._status is not None:
+            self._status.update(msg)
+
+    def _status_stop(self) -> None:
+        if self._status is not None:
+            self._status.stop()
+            self._status = None
+
+    def begin_response(self) -> None:
+        self._think_start = None
+        self._think_chars = 0
+        self._content_started = False
+        self._reasoning_printed = False
+        self._status_start("Waiting for Euron Code...")
+
+    def waiting(self, msg: str) -> None:
+        if not self._content_started:
+            self._status_start(msg)
+
+    def reasoning(self, text: str) -> None:
+        if self._think_start is None:
+            self._think_start = time.monotonic()
+        self._think_chars += len(text)
+        if self.reasoning_mode == "show":
+            self._status_stop()
+            self.console.print(Text(text, style="dim italic"), end="")
+            self._reasoning_printed = True
+        elif self.reasoning_mode == "collapse":
+            secs = time.monotonic() - self._think_start
+            self._status_start(f"Thinking... {secs:.0f}s  (/thinking to show)")
+
+    def _close_reasoning(self) -> None:
+        if self._think_start is not None:
+            secs = time.monotonic() - self._think_start
+            if self.reasoning_mode == "show" and self._reasoning_printed:
+                self.console.print()
+            elif self.reasoning_mode == "collapse":
+                self.console.print(Text(f"(thought for {secs:.0f}s)", style="dim"))
+            self._think_start = None
+
+    def content(self, text: str) -> None:
+        if not self._content_started:
+            self._status_stop()
+            self._close_reasoning()
+            self._content_started = True
+        self.console.print(Text(text), end="")
+
+    def tool_call_pending(self, name: str) -> None:
+        if not self._content_started:
+            self._status_start(f"Preparing {name}...")
+
+    def end_response(self) -> None:
+        self._status_stop()
+        self._close_reasoning()
+        if self._content_started:
+            self.console.print()
+        self._content_started = False
+
+    # ---------------------------------------------------------- tools
+    def tool_start(self, name: str, summary: str) -> None:
+        self.console.print(Text.assemble(("> ", "bold cyan"), (name, "bold"), ("  " + summary, "")))
+
+    def tool_result(self, preview: str, is_error: bool = False) -> None:
+        style = "red" if is_error else "dim"
+        lines = preview.splitlines()[:6]
+        if not lines:
+            lines = ["(no output)"]
+        for ln in lines:
+            self.console.print(Text("  " + ln[:200], style=style))
+        if len(preview.splitlines()) > 6:
+            self.console.print(Text(f"  ... ({len(preview.splitlines()) - 6} more lines)", style="dim"))
+
+    def show_diff(self, diff: str) -> None:
+        if not diff.strip():
+            self.dim("  (no textual change)")
+            return
+        shown = diff.splitlines()
+        limit = 120
+        for ln in shown[:limit]:
+            if ln.startswith("+++") or ln.startswith("---"):
+                style = "bold"
+            elif ln.startswith("+"):
+                style = "green"
+            elif ln.startswith("-"):
+                style = "red"
+            elif ln.startswith("@@"):
+                style = "cyan"
+            else:
+                style = "dim"
+            self.console.print(Text("  " + ln, style=style))
+        if len(shown) > limit:
+            self.dim(f"  ... diff truncated ({len(shown) - limit} more lines)")
+
+    def show_todos(self, todos: List[Dict[str, Any]]) -> None:
+        if not todos:
+            self.dim("  (todo list cleared)")
+            return
+        for t in todos:
+            st = t.get("status", "pending")
+            mark = {"completed": "[x]", "in_progress": "[~]"}.get(st, "[ ]")
+            style = {"completed": "dim strike", "in_progress": "bold yellow"}.get(st, "")
+            self.console.print(Text(f"  {mark} {t.get('content', '')}", style=style))
+
+    # ---------------------------------------------------------- prompts
+    def ask_permission(self, title: str, detail: Optional[str], options: List[tuple]) -> str:
+        """options: list of (key, label). Returns the chosen key ('n' on EOF)."""
+        self._status_stop()
+        self.console.print(Text.assemble(("? ", "bold yellow"), (title, "bold")))
+        if detail:
+            for ln in detail.splitlines()[:40]:
+                self.console.print(Text("    " + ln))
+        labels = "  ".join(f"[{k}] {escape(lbl)}" for k, lbl in options)
+        valid = {k for k, _ in options}
+        while True:
+            self.console.print(Text("  " + labels, style="cyan"))
+            try:
+                ans = input("  > ").strip().lower()
+            except (EOFError, KeyboardInterrupt):
+                self.console.print()
+                return "n"
+            if not ans:
+                ans = "n"
+            if ans in valid:
+                return ans
+            if ans in ("yes",):
+                return "y"
+            if ans in ("no",):
+                return "n"
+
+    def ask_text(self, prompt: str) -> str:
+        try:
+            return input(prompt)
+        except (EOFError, KeyboardInterrupt):
+            return ""
+
+    def countdown(self, seconds: float, message: str, cancel: Optional[threading.Event] = None) -> None:
+        """Visible countdown. Raises KeyboardInterrupt if the user presses Ctrl-C."""
+        self._status_stop()
+        end = time.monotonic() + seconds
+        if self.console.is_terminal:
+            with self.console.status("") as st:
+                while True:
+                    left = end - time.monotonic()
+                    if left <= 0:
+                        break
+                    if cancel is not None and cancel.is_set():
+                        break
+                    st.update(f"{message} retrying in {left:.0f}s (Ctrl-C to stop)")
+                    time.sleep(min(0.25, left))
+        else:
+            self.warn(f"{message} retrying in {seconds:.0f}s")
+            while time.monotonic() < end:
+                if cancel is not None and cancel.is_set():
+                    break
+                time.sleep(min(0.25, max(0.0, end - time.monotonic())))
+
+
+class QuietUI(UI):
+    """Used by `euron -p`: no spinners, progress on stderr, never prompts."""
+
+    interactive = False
+
+    def __init__(self, verbose: bool = False):
+        super().__init__(reasoning="hide", stderr=True)
+        self.verbose = verbose
+
+    def begin_response(self) -> None:
+        pass
+
+    def waiting(self, msg: str) -> None:
+        pass
+
+    def reasoning(self, text: str) -> None:
+        pass
+
+    def content(self, text: str) -> None:
+        if self.verbose:
+            self.console.print(Text(text), end="")
+
+    def tool_call_pending(self, name: str) -> None:
+        pass
+
+    def end_response(self) -> None:
+        if self.verbose:
+            self.console.print()
+
+    def tool_start(self, name: str, summary: str) -> None:
+        if self.verbose:
+            super().tool_start(name, summary)
+
+    def tool_result(self, preview: str, is_error: bool = False) -> None:
+        if self.verbose:
+            super().tool_result(preview, is_error)
+
+    def show_diff(self, diff: str) -> None:
+        if self.verbose:
+            super().show_diff(diff)
+
+    def show_todos(self, todos):
+        if self.verbose:
+            super().show_todos(todos)
+
+    def ask_permission(self, title, detail, options) -> str:
+        self.console.print(Text(f"Denied (non-interactive, use --allowed-tools or --yolo): {title}",
+                                style="yellow"))
+        return "n"
+
+
+def is_tty() -> bool:
+    try:
+        return sys.stdin.isatty() and sys.stdout.isatty()
+    except (AttributeError, ValueError):
+        return False

euron_code/usage_view.py

@@ -0,0 +1,108 @@
+"""Rendering for `euron usage`, `/usage`, `whoami` and the status line."""
+
+from __future__ import annotations
+
+import datetime as _dt
+from typing import Any, Dict, Optional
+
+from rich.table import Table
+
+from euron_code import api
+
+
+def fmt_int(n: Any) -> str:
+    try:
+        return f"{int(n):,}"
+    except (TypeError, ValueError):
+        return "-"
+
+
+def short(n: Any) -> str:
+    try:
+        n = int(n)
+    except (TypeError, ValueError):
+        return "-"
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.1f}M"
+    if n >= 10_000:
+        return f"{n / 1000:.0f}k"
+    if n >= 1000:
+        return f"{n / 1000:.1f}k"
+    return str(n)
+
+
+def local_time(iso: Optional[str]) -> str:
+    if not iso:
+        return "-"
+    try:
+        s = iso.replace("Z", "+00:00")
+        dt = _dt.datetime.fromisoformat(s)
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=_dt.timezone.utc)
+        local = dt.astimezone()
+        return local.strftime("%Y-%m-%d %H:%M %Z").strip()
+    except ValueError:
+        return iso
+
+
+def render_account(ui, me: Dict[str, Any]) -> None:
+    user = me.get("user") or {}
+    access = me.get("access") or {}
+    quota = me.get("quota") or {}
+    totals = me.get("totals") or {}
+    ui.info(f"[bold]{user.get('name') or ''}[/bold] <{user.get('email') or ''}>")
+    ui.info(f"Plan:           {api.plan_label(access)}")
+    limit = quota.get("dailyTokenLimit")
+    used = quota.get("usedToday")
+    ui.info(f"Tokens today:   {fmt_int(used)} / {fmt_int(limit)}"
+            + (f"  ({int(used) * 100 // max(1, int(limit))}%)" if used is not None and limit else ""))
+    ui.info(f"Remaining:      {fmt_int(quota.get('remainingToday'))}")
+    ui.info(f"Resets at:      {local_time(quota.get('resetsAt'))}")
+    ui.info(f"All time:       {fmt_int(totals.get('allTimeTokens'))} tokens, "
+            f"{fmt_int(totals.get('allTimeRequests'))} requests")
+    if quota.get("requestsPerMinute"):
+        ui.dim(f"Limits: {quota.get('requestsPerMinute')} requests/min, "
+               f"{quota.get('perUserConcurrency') or 1} at a time. Default model: {me.get('defaultModel') or '-'}")
+
+
+def render_usage(ui, me: Dict[str, Any], usage: Optional[Dict[str, Any]]) -> None:
+    render_account(ui, me)
+    if not usage:
+        return
+    days = usage.get("days") or []
+    t = Table(title="Last 30 days", show_edge=False, header_style="bold")
+    t.add_column("Day")
+    t.add_column("Requests", justify="right")
+    t.add_column("Completed", justify="right")
+    t.add_column("Prompt", justify="right")
+    t.add_column("Completion", justify="right")
+    t.add_column("Total", justify="right")
+    tot = 0
+    for d in sorted(days, key=lambda d: d.get("day", ""), reverse=True):
+        p = int(d.get("promptTokens") or 0)
+        c = int(d.get("completionTokens") or 0)
+        tot += p + c
+        t.add_row(str(d.get("day", "")), fmt_int(d.get("requests")), fmt_int(d.get("completed")),
+                  fmt_int(p), fmt_int(c), fmt_int(p + c))
+    ui.info("")
+    if days:
+        ui.console.print(t)
+        ui.dim(f"30-day total: {fmt_int(tot)} tokens")
+    else:
+        ui.dim("No usage in the last 30 days.")
+
+
+def status_line(model: str, session_tokens: int, me: Optional[Dict[str, Any]], mode: str,
+                context_pct: Optional[int] = None) -> str:
+    parts = [model]
+    parts.append(f"session {short(session_tokens)} tok")
+    if context_pct is not None:
+        parts.append(f"context {context_pct}%")
+    if me:
+        q = me.get("quota") or {}
+        rem = q.get("remainingToday")
+        if rem is not None:
+            parts.append(f"today {short(rem)} left of {short(q.get('dailyTokenLimit'))}")
+    if mode != "default":
+        parts.append(f"mode: {mode}")
+    return " | ".join(parts)

euron_code-0.1.0.dist-info/METADATA

@@ -0,0 +1,278 @@
+Metadata-Version: 2.5
+Name: euron-code
+Version: 0.1.0
+Summary: Euron Code: an agentic coding assistant in your terminal for Euron Plus and Super 30 students.
+Project-URL: Homepage, https://euron.one/code-agent
+Author-email: Euron <contact@euron.one>
+License: Copyright (c) 2026 Euron. All rights reserved.
+        
+        This software and its source code, documentation and associated files (the
+        "Software") are proprietary to Euron and are protected by copyright law.
+        
+        Euron grants you a limited, non-exclusive, non-transferable, revocable licence
+        to install and run the Software solely to access the Euron Code service with an
+        Euron account that is entitled to it (for example Euron Plus or Super 30).
+        
+        You may not, without the prior written permission of Euron:
+          - copy, modify, merge, publish, distribute, sublicense or sell the Software
+            or any part of it;
+          - reverse engineer, decompile or disassemble the Software, except to the
+            extent that applicable law expressly permits it;
+          - use the Software to access any service other than Euron Code, or to
+            circumvent any access control, quota or rate limit of the service.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+        FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL EURON BE LIABLE
+        FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+        TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+        THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+License-File: LICENSE
+Keywords: ai,assistant,cli,coding agent,euron
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Requires-Python: >=3.9
+Requires-Dist: httpx<1,>=0.24
+Requires-Dist: keyring>=23.0
+Requires-Dist: prompt-toolkit>=3.0.30
+Requires-Dist: rich>=13.0
+Provides-Extra: db
+Requires-Dist: psycopg[binary]>=3.1; extra == 'db'
+Requires-Dist: pymysql>=1.0; extra == 'db'
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Provides-Extra: mysql
+Requires-Dist: pymysql>=1.0; extra == 'mysql'
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary]>=3.1; extra == 'postgres'
+Description-Content-Type: text/markdown
+
+# Euron Code
+
+An AI coding agent for your terminal, made for Euron students. Ask it to explain a codebase, fix a
+bug, write tests or build a feature: it reads your files, proposes edits, runs commands and checks
+its own work, asking you before it changes anything.
+
+Euron Code runs on your computer. Only the conversation goes to Euron's model servers.
+
+> **Requires Euron Plus or Super 30.** Euron Code is included with both. Get Plus at
+> https://euron.one/plus
+
+## Install
+
+Python 3.9 or newer, on Windows, macOS or Linux.
+
+```bash
+pip install euron-code
+# or, to keep it isolated from your projects:
+pipx install euron-code
+```
+
+Optional database drivers for the database explorer:
+
+```bash
+pip install "euron-code[postgres]"   # Postgres
+pip install "euron-code[mysql]"      # MySQL / MariaDB
+```
+
+Check the install with `euron --version` and `euron doctor`.
+
+## Log in
+
+```bash
+euron login
+```
+
+Your browser opens a Euron page that shows a code (for example `WXYZ-1234`). Check that it matches
+the code in your terminal and click **Approve**. The terminal finishes by itself. If no browser opens
+(SSH, WSL), copy the link it prints into any browser where you are logged in to euron.one.
+
+Your key is saved in the system keychain (Windows Credential Manager, macOS Keychain, Linux Secret
+Service). If there is no keychain it goes in `~/.euron/credentials.json`, readable only by you.
+
+```bash
+euron whoami     # who you are logged in as, and your plan
+euron logout     # remove the key from this computer
+```
+
+## Use it
+
+Open a terminal **in your project folder** and run:
+
+```bash
+euron
+```
+
+Then type what you want, for example:
+
+- `explain how authentication works in this project`
+- `the tests in tests/test_api.py fail, find out why and fix it`
+- `add input validation to the signup form and a test for it`
+
+Euron Code works step by step: it looks around, reads files, shows you a diff before each edit, and
+asks before running commands. Answer:
+
+| Key | Meaning |
+|---|---|
+| `y` | yes, once |
+| `n` | no (you can then tell it what to do instead) |
+| `a` | always allow this for the rest of the session |
+| `p` | always allow commands starting the same way (e.g. every `npm test ...`) this session |
+| `s` | always, and save the rule to `.euron/settings.local.json` |
+
+Press **Esc** or **Ctrl-C** to stop a reply; the session stays open. **Ctrl-D** or `/exit` quits.
+**Esc then Enter** inserts a newline.
+
+### Commands inside a session
+
+| Command | What it does |
+|---|---|
+| `/help` | list commands |
+| `/usage` | plan, tokens used today and your daily limit, reset time, last 30 days |
+| `/cost` | tokens used in this session |
+| `/model [id]` | show or switch the model |
+| `/compact [focus]` | summarise the conversation to free context |
+| `/clear` | start a fresh conversation |
+| `/memory`, `/memory edit` | show or edit `EURON.md` memory |
+| `/init` | let Euron Code explore the repo and write `EURON.md` |
+| `/permissions` | show rules; `/permissions mode acceptEdits`, `/permissions allow "Bash(pytest:*)"` |
+| `/thinking show\|collapse\|hide` | how the model's reasoning is displayed |
+| `/todos` | the current task list |
+| `/doctor` | check your setup |
+| `/login`, `/logout`, `/exit` | |
+| `# some note` | save a note to memory (asks: project or user) |
+
+The bar at the bottom shows the model, tokens used this session, how full the context is, and how
+many tokens you have left today.
+
+### Continue later
+
+Every session is saved under `~/.euron/sessions/`.
+
+```bash
+euron --continue     # pick up the latest session in this folder
+euron --resume       # choose from a list
+```
+
+### Usage and limits
+
+```bash
+euron usage
+```
+
+shows your plan (Euron Plus / Super 30), tokens today out of your daily limit, what is left, when it
+resets (in your local time), all-time totals and a day-by-day table for the last 30 days. The daily
+allowance resets at midnight IST.
+
+Euron Code sends one request at a time per student. When the servers are busy it waits and retries
+by itself, and tells you.
+
+## Memory: EURON.md
+
+Put project instructions in `EURON.md` at the project root (commands to build and test, conventions,
+things to avoid). Euron Code reads it at the start of every session, together with `EURON.md` files in
+parent folders up to the git root and your personal `~/.euron/EURON.md`. Run `/init` to have a first
+version written for you.
+
+## Non-interactive use (scripts, CI)
+
+```bash
+euron -p "summarise what this repo does"
+git diff | euron -p "review this diff"
+euron -p "run the tests and fix failures" --allowed-tools "Edit,Bash(pytest:*)" --max-turns 20
+euron -p "list the API routes" --output-format json
+```
+
+In `-p` mode nothing can ask you, so anything that needs permission is refused unless an allow rule
+covers it (`--allowed-tools`, or settings). `--yolo` skips all prompts: only use it in a throwaway
+folder or container.
+
+Exit codes: `0` ok, `1` error, `2` bad usage, `3` no Euron Plus / Super 30 access, `4` not logged in or
+key rejected, `5` daily token allowance used, `6` `--max-turns` reached, `130` interrupted.
+
+## Database explorer
+
+Euron Code can look at your app's database while it works. SQLite files inside the project work
+directly (`look at app.db and tell me which tables have no index`). For Postgres or MySQL, name a
+connection in your settings; `${VAR}` reads from the environment so passwords stay out of the file:
+
+```bash
+euron config set --project db.connections.app "postgresql://dev:${PGPASSWORD}@localhost:5432/app"
+```
+
+It is **read-only**: only `SELECT`, `WITH`, `EXPLAIN`, `SHOW`, `PRAGMA` and similar are allowed, and
+the connection itself is opened read-only. To let it write (local dev databases only), run
+`euron config set db.allowWrites true`; every write statement still asks you first.
+
+## Settings
+
+`euron config set <key> <value>` writes `~/.euron/settings.json` (add `--project` for
+`.euron/settings.json` in the current folder). `euron config list` shows the merged result.
+
+| Key | Default | |
+|---|---|---|
+| `model` | your account default | model id |
+| `reasoning` | `collapse` | `show`, `collapse` or `hide` the model's thinking |
+| `permissions.allow` / `permissions.deny` | `[]` | rules like `Edit`, `Bash(npm test:*)`, `WebFetch(domain:docs.python.org)`, `Read(~/notes/**)` |
+| `permissions.defaultMode` | `default` | `default`, `acceptEdits` (edits inside the project need no prompt) or `yolo` |
+| `bashTimeout` | `120` | seconds before a command is stopped |
+| `shell` | auto | PowerShell on Windows, bash/zsh elsewhere; or `cmd`, `bash`, a path |
+| `autoCompact` | `true` | summarise old turns when the context is 75% full |
+| `webFetch` | `true` | allow the web page tool (it still asks per site) |
+| `db.connections.<name>` | | database DSNs |
+
+Environment variables: `EURON_CODE_API` (gateway URL, default
+`https://api.euron.one/api/v1/code-agent`), `EURON_API_KEY` (use a key without logging in, for CI),
+`EURON_HOME` (instead of `~/.euron`), `EURON_NO_BROWSER=1`.
+
+## In VS Code
+
+Open your project folder in VS Code, then open the integrated terminal (**Ctrl+`**, or
+**Terminal > New Terminal**) and run `euron`. It works in the folder VS Code opened, and edits show up
+in the editor straight away. Tips:
+
+- On Windows the integrated terminal is PowerShell by default; Euron Code runs commands with
+  PowerShell too. To use Git Bash instead: `euron config set shell bash`.
+- If `euron` is not found after `pip install`, the Python `Scripts` folder is not on your PATH.
+  Use `python -m euron_code`, or install with `pipx` (`pipx ensurepath`), then restart VS Code.
+- Keep your edits saved before asking Euron Code to change the same file.
+
+## Troubleshooting
+
+| You see | What to do |
+|---|---|
+| `You don't have Euron Plus access...` | Euron Code needs Euron Plus or an active Super 30 enrolment: https://euron.one/plus |
+| `not logged in` / `key was rejected` | run `euron login` again (keys can be revoked at euron.one/code-agent) |
+| `servers are busy, retrying` | normal at peak times; it retries for you. If it gives up, try again in a few minutes |
+| `Rate limit reached` | too many requests in one minute; it waits and retries |
+| `today's token allowance` | you used today's limit; it resets at the time shown (midnight IST) |
+| `The response stopped part-way` | the connection dropped mid-answer; nothing more was applied, send your message again |
+| `euron: command not found` | see the VS Code tips above, or run `python -m euron_code` |
+| garbled colours on old Windows consoles | use Windows Terminal or VS Code's terminal |
+
+`euron doctor` checks Python, the connection, your login and plan, ripgrep (faster search; optional)
+and the keychain.
+
+## Privacy and safety
+
+- Your files are only sent as part of the conversation with Euron's model, and only what the agent
+  reads. Nothing is uploaded anywhere else. There is no telemetry.
+- Your key is never printed in full and never logged.
+- Edits and commands ask first. Files outside the project folder always ask, even to read.
+- Text inside your files, web pages and command output is treated as data, not instructions.
+
+## Licence
+
+Copyright (c) 2026 Euron. All rights reserved. See `LICENSE`.

euron_code-0.1.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+euron_code/__init__.py,sha256=-JSAXxKntRgF38xYMKR_2W6khJ1qD3xaHDLiVx4l2co,87
+euron_code/__main__.py,sha256=m8iDBDA7e9XBlUTpLwMit61zzAtyctk9rySLTMkYU-w,89
+euron_code/agent.py,sha256=aRP2ZGirzIIzX3DUT26J3-gJkq8xyEXscgk84vrao8c,27903
+euron_code/api.py,sha256=LsiRFzxD0DxXDXVt9yBfaEyAJ64eAUIICOhZMs9WoFg,14108
+euron_code/auth.py,sha256=UpRfDkzIokl3hK_zzhjk2SnBJy6BzWG2WpUzr6dLBdU,4290
+euron_code/cli.py,sha256=krvG6kYow7GImIhmLdm8OuSMPKiGKKkGo-tZgBiQaSY,14633
+euron_code/config.py,sha256=5SGxnpSO244PwekWTBpoIySUF_kC59MBreZxBDg_Q9U,6379
+euron_code/context.py,sha256=M3odv5vDwTtPFZUwsT4cnmgFhr-InffgxJy2IvKr9Iw,5184
+euron_code/credentials.py,sha256=gCyLXdkVw0Jzf27BBJEUO-qE_d48bm3KwkuO-7Ec4Ck,5640
+euron_code/doctor.py,sha256=KFB4T4I0aCuTtGs1Kg_fLxY_bZH-ftITbDDg-WS8B9s,3980
+euron_code/keys.py,sha256=Bop0hzB0-Dtz5ag1GY7Zj_JxH-8RfCuZ2qWI4GLvVZ8,3111
+euron_code/memory.py,sha256=hWgeZVpdW9Gki5UW6E9Qdz1MXXv7_HZaZqOo8JYwFvM,2797
+euron_code/permissions.py,sha256=st8YKhKDCKgXyAymwuEJVOWkt6OukG5OtoNwdokqK-0,9126
+euron_code/prompts.py,sha256=V6ZrVh213ADAnM0MMLfvFEZqJNyOxYMt7HPzb4EKlJ8,6806
+euron_code/repl.py,sha256=-pxA64pNQmuZTvCXNjD4UWoh6XPF84wUefp39Ql0GQI,18676
+euron_code/sessions.py,sha256=EcQyRmOZuN16V87aNDJjLIFjF3jJsusdqWokFsFnxXQ,6401
+euron_code/ui.py,sha256=27ccBlSfxrgFVsD838rRmXs-zgVP3Uzk0tbvZS-ldtM,10010
+euron_code/usage_view.py,sha256=oE_dty6Ondzy58coPD3KQNU6787kYgPLO3T6bchH7Vg,3759
+euron_code/tools/__init__.py,sha256=TEY2vc-trh7v01io8Ynui0f8WIEuyHoDexoyKzMoKLw,1185
+euron_code/tools/base.py,sha256=2h6Sk9tsAapI-QTHnol-Se8ff5uRo2opDIR7ZAzBUZk,5341
+euron_code/tools/db.py,sha256=c0KmvI6vYgfoN-vIkJ2jU-MkHpKCUfnSMKMKWm9KQ2c,16199
+euron_code/tools/fs.py,sha256=l1LQB7KYmh2pL9VwV1wiXjM9iSrqfQr-0dbRSIqudFg,16718
+euron_code/tools/ignore.py,sha256=BgUeDjafw5OptbaDMcyOreqvo8SttqRTpJOmA7_cNHk,2564
+euron_code/tools/search.py,sha256=dCPjitKwMP2jJwYQ7G_y5HgcK4l_bORqQNsPL4kFOBg,8145
+euron_code/tools/shell.py,sha256=7Yaz6Te66bn-iSQ1F59BmWMd2peX-QEcKAu8gLgIHvI,9024
+euron_code/tools/task.py,sha256=PjbKTOqdlhveEZOPH0kw6GnYO3yC_UdTF_9VeqObJSI,1796
+euron_code/tools/todo.py,sha256=rAaPBTQtclaYwOCkIrN3nm3bJEeivPjk8L5ytJqtBxs,2395
+euron_code/tools/web.py,sha256=u1YXw8YYAkrYe9aKXFjlX32tylF7EMzn0Ir8o5WHYBk,4412
+euron_code-0.1.0.dist-info/METADATA,sha256=PJY4k8jFaKP-DtMEeWIx1K0DMmTfCViOrXza4Hz5eiQ,12122
+euron_code-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+euron_code-0.1.0.dist-info/entry_points.txt,sha256=qFTCov7iu3CjrtINB2m-2F6lHJxMG7weDsTwFJgat58,46
+euron_code-0.1.0.dist-info/licenses/LICENSE,sha256=baMUtwGYv0eYJNB0Hs5Hl07el2JuomxzvvOfddNMkNQ,1300
+euron_code-0.1.0.dist-info/RECORD,,