euron-coding-agent 0.1.0__py3-none-any.whl

euron_agent/__init__.py

@@ -0,0 +1,9 @@
+"""Euron Agent — a lightweight, provider-agnostic agentic coding backend.
+
+Public surface:
+    from euron_agent.config import load_config
+    from euron_agent.llm import build_client
+    from euron_agent.loop import AgentSession
+"""
+
+__version__ = "0.1.0"

euron_agent/__main__.py

@@ -0,0 +1,7 @@
+"""Enable `python -m euron_agent ...` (used by the VS Code auto-start)."""
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

euron_agent/cli.py

@@ -0,0 +1,286 @@
+"""Command-line interface.
+
+    euron-agent run "add a /health route to app.py"   # one-shot in cwd
+    euron-agent chat                                   # interactive REPL
+    euron-agent serve                                  # start the API server
+    euron-agent providers                              # list configured providers
+    euron-agent init                                   # scaffold config.yaml/.env
+
+The CLI uses the very same AgentSession/loop as the VS Code backend, so the
+terminal experience and the editor experience are identical.
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import shutil
+import sys
+from pathlib import Path
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+
+from .config import load_config
+from .events import AgentIO, ApprovalDecision
+from .loop import AgentSession
+
+
+def _force_utf8() -> None:
+    """Avoid UnicodeEncodeError for box-drawing/emoji on Windows code pages."""
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[attr-defined]
+        except Exception:
+            pass
+
+
+_force_utf8()
+# legacy_windows=False -> use ANSI (Windows 10+ supports it) instead of the
+# win32 console API, which encodes with the active code page and chokes on '●'.
+console = Console(legacy_windows=False)
+
+
+# --------------------------------------------------------------------------- #
+# Terminal IO
+# --------------------------------------------------------------------------- #
+class TerminalIO(AgentIO):
+    def __init__(self, auto_approve: bool):
+        self.auto_approve = auto_approve
+        self._dirty = False  # unfinished streamed line on screen
+
+    def _newline_if_dirty(self) -> None:
+        if self._dirty:
+            sys.stdout.write("\n")
+            sys.stdout.flush()
+            self._dirty = False
+
+    # streamed tokens (may arrive from a worker thread)
+    def on_token(self, text: str) -> None:
+        sys.stdout.write(text)
+        sys.stdout.flush()
+        self._dirty = True
+
+    async def emit(self, event: dict) -> None:
+        t = event["type"]
+        if t == "status":
+            return  # keep the terminal quiet; spinners would fight streaming
+        if t == "assistant_message":
+            # text already streamed via tokens; just close the line
+            self._newline_if_dirty()
+            return
+        self._newline_if_dirty()
+        if t == "tool_start":
+            args = event["args"]
+            detail = args.get("path") or args.get("command") or args.get("query") or ""
+            console.print(f"[cyan]⚙ {event['name']}[/cyan] [dim]{detail}[/dim]")
+        elif t == "diff":
+            self._print_diff(event["patch"])
+        elif t == "tool_result":
+            mark = "[green]✓[/green]" if event["ok"] else "[red]✗[/red]"
+            out = (event["output"] or "").strip()
+            if out:
+                snippet = out if len(out) < 1200 else out[:1200] + " …"
+                console.print(f"{mark} [dim]{snippet}[/dim]")
+        elif t == "error":
+            console.print(f"[red]error:[/red] {event['message']}")
+        elif t == "done":
+            console.print("[dim]— done —[/dim]")
+
+    def _print_diff(self, patch: str) -> None:
+        for line in patch.splitlines():
+            if line.startswith("+") and not line.startswith("+++"):
+                console.print(f"[green]{line}[/green]")
+            elif line.startswith("-") and not line.startswith("---"):
+                console.print(f"[red]{line}[/red]")
+            elif line.startswith("@@"):
+                console.print(f"[magenta]{line}[/magenta]")
+            else:
+                console.print(f"[dim]{line}[/dim]")
+
+    async def request_approval(self, request: dict) -> ApprovalDecision:
+        self._newline_if_dirty()
+        preview = request.get("preview") or ""
+        title = f"Approve {request['name']}?"
+        if preview:
+            self._print_diff(preview) if "\n" in preview and (
+                "+++" in preview or "@@" in preview
+            ) else console.print(Panel(preview, title=title, border_style="yellow"))
+        if self.auto_approve:
+            console.print("[green]auto-approved[/green]")
+            return ApprovalDecision(approved=True)
+
+        answer = await asyncio.to_thread(
+            Prompt.ask,
+            f"[yellow]{title}[/yellow] (y/n, or type feedback to reject)",
+            default="y",
+        )
+        a = answer.strip().lower()
+        if a in ("y", "yes", ""):
+            return ApprovalDecision(approved=True)
+        if a in ("n", "no"):
+            return ApprovalDecision(approved=False, feedback="rejected by user")
+        return ApprovalDecision(approved=False, feedback=answer.strip())
+
+
+# --------------------------------------------------------------------------- #
+# Commands
+# --------------------------------------------------------------------------- #
+async def _run_task(task: str, args) -> None:
+    cfg = load_config(args.config, provider=args.provider, model=args.model)
+    if args.yes:
+        cfg.agent.auto_approve_writes = True
+        cfg.agent.auto_approve_commands = True
+    workspace = str(Path(args.workspace).resolve())
+    console.print(
+        f"[dim]workspace={workspace} · provider={cfg.provider.name} · "
+        f"model={cfg.provider.model}[/dim]"
+    )
+    io = TerminalIO(auto_approve=args.yes)
+    session = AgentSession(workspace, cfg, io)
+    await session.run(task)
+
+
+def cmd_run(args) -> None:
+    asyncio.run(_run_task(args.task, args))
+
+
+async def _chat(args) -> None:
+    cfg = load_config(args.config, provider=args.provider, model=args.model)
+    if args.yes:
+        cfg.agent.auto_approve_writes = True
+        cfg.agent.auto_approve_commands = True
+    workspace = str(Path(args.workspace).resolve())
+    io = TerminalIO(auto_approve=args.yes)
+    session = AgentSession(workspace, cfg, io)  # one session => memory across turns
+    console.print(
+        Panel(
+            f"Euron Agent · [bold]{cfg.provider.name}[/bold] / {cfg.provider.model}\n"
+            f"workspace: {workspace}\n"
+            "Type a task. Commands: /exit, /reset, /yes (toggle auto-approve).",
+            border_style="cyan",
+        )
+    )
+    while True:
+        try:
+            msg = await asyncio.to_thread(Prompt.ask, "[bold cyan]you[/bold cyan]")
+        except (EOFError, KeyboardInterrupt):
+            break
+        msg = msg.strip()
+        if not msg:
+            continue
+        if msg in ("/exit", "/quit"):
+            break
+        if msg == "/reset":
+            session.messages.clear()
+            console.print("[dim]context cleared[/dim]")
+            continue
+        if msg == "/yes":
+            io.auto_approve = not io.auto_approve
+            console.print(f"[dim]auto-approve = {io.auto_approve}[/dim]")
+            continue
+        await session.run(msg)
+    console.print("[dim]bye[/dim]")
+
+
+def cmd_chat(args) -> None:
+    asyncio.run(_chat(args))
+
+
+def cmd_serve(args) -> None:
+    from .server import serve
+
+    console.print(f"[cyan]Euron Agent server[/cyan] on http://{args.host}:{args.port}")
+    serve(host=args.host, port=args.port, reload=args.reload)
+
+
+def cmd_providers(args) -> None:
+    from rich.table import Table
+
+    cfg = load_config(args.config)
+    table = Table(title="Configured providers")
+    table.add_column("name")
+    table.add_column("active")
+    table.add_column("type")
+    table.add_column("model")
+    table.add_column("base_url")
+    for name, p in cfg.all_providers.items():
+        table.add_row(
+            name,
+            "●" if name == cfg.provider.name else "",
+            p.type,
+            p.model,
+            p.base_url or "(default)",
+        )
+    console.print(table)
+
+
+def cmd_init(args) -> None:
+    backend = Path(__file__).resolve().parent.parent
+    pairs = [("config.example.yaml", "config.yaml"), (".env.example", ".env")]
+    for src, dst in pairs:
+        dst_path = Path.cwd() / dst
+        src_path = backend / src
+        if dst_path.exists():
+            console.print(f"[yellow]skip[/yellow] {dst} already exists")
+        elif src_path.exists():
+            shutil.copy(src_path, dst_path)
+            console.print(f"[green]created[/green] {dst}")
+        else:
+            console.print(f"[red]missing template[/red] {src}")
+    console.print("Edit config.yaml (pick a provider) and .env (add your key).")
+
+
+# --------------------------------------------------------------------------- #
+# Parser
+# --------------------------------------------------------------------------- #
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="euron-agent", description="Euron coding agent.")
+    p.add_argument("--config", help="Path to config.yaml")
+    p.add_argument("--provider", help="Override active provider profile")
+    p.add_argument("--model", help="Override model id")
+    p.add_argument(
+        "--workspace", default=os.getcwd(), help="Workspace root (default: cwd)"
+    )
+    sub = p.add_subparsers(dest="command", required=True)
+
+    r = sub.add_parser("run", help="Run a single task and exit")
+    r.add_argument("task")
+    r.add_argument("--yes", "-y", action="store_true", help="Auto-approve all actions")
+    r.set_defaults(func=cmd_run)
+
+    c = sub.add_parser("chat", help="Interactive REPL")
+    c.add_argument("--yes", "-y", action="store_true", help="Auto-approve all actions")
+    c.set_defaults(func=cmd_chat)
+
+    s = sub.add_parser("serve", help="Start the FastAPI server")
+    s.add_argument("--host", default="127.0.0.1")
+    s.add_argument("--port", type=int, default=8000)
+    s.add_argument("--reload", action="store_true")
+    s.set_defaults(func=cmd_serve)
+
+    sub.add_parser("providers", help="List configured providers").set_defaults(
+        func=cmd_providers
+    )
+    sub.add_parser("init", help="Scaffold config.yaml and .env").set_defaults(
+        func=cmd_init
+    )
+    return p
+
+
+def main(argv=None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        args.func(args)
+    except KeyboardInterrupt:
+        console.print("\n[dim]interrupted[/dim]")
+        return 130
+    except Exception as e:  # noqa: BLE001
+        console.print(f"[red]fatal:[/red] {type(e).__name__}: {e}")
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

euron_agent/config.py

@@ -0,0 +1,203 @@
+"""Configuration loading and resolution.
+
+Config is layered, in order of precedence (later wins):
+  1. built-in defaults
+  2. config.yaml (next to the package, the cwd, or $EURON_AGENT_CONFIG)
+  3. environment variables (.env is loaded automatically)
+  4. explicit overrides passed on the CLI / API call
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field, replace
+from pathlib import Path
+from typing import Any, Optional
+
+import yaml
+from dotenv import load_dotenv
+
+load_dotenv()  # pull .env into os.environ if present
+
+
+# --------------------------------------------------------------------------- #
+# Dataclasses
+# --------------------------------------------------------------------------- #
+@dataclass
+class ProviderConfig:
+    name: str
+    type: str = "openai"  # "openai" (OpenAI-compatible) or "anthropic"
+    base_url: Optional[str] = None
+    api_key_env: Optional[str] = None
+    api_key: Optional[str] = None  # resolved from api_key_env at load time
+    model: str = "gpt-4o-mini"
+    temperature: float = 0.2
+    max_tokens: int = 4096
+    extra_headers: dict = field(default_factory=dict)
+
+
+@dataclass
+class AgentConfig:
+    max_steps: int = 30
+    stream: bool = True
+    auto_approve_reads: bool = True
+    auto_approve_writes: bool = False
+    auto_approve_commands: bool = False
+    max_file_bytes: int = 120_000
+    max_command_seconds: int = 60
+
+
+@dataclass
+class Config:
+    provider: ProviderConfig
+    agent: AgentConfig
+    ignore: list[str] = field(default_factory=list)
+    all_providers: dict[str, ProviderConfig] = field(default_factory=dict)
+
+
+DEFAULT_IGNORE = [
+    ".git/**", "node_modules/**", "__pycache__/**", ".venv/**", "venv/**",
+    "dist/**", "build/**", "*.lock", ".env", ".env.*",
+]
+
+# Built-in provider profiles so the extension (and a fresh install with no
+# config.yaml) works out of the box: the user just picks a provider and supplies
+# a key. Any of these can be overridden by a user-defined provider of the same
+# name in config.yaml.
+BUILTIN_PROVIDERS: dict[str, dict] = {
+    "euri": {
+        "type": "openai",
+        "base_url": "https://api.euron.one/api/v1",
+        "api_key_env": "EURI_API_KEY",
+        "model": "gpt-4.1-mini",
+    },
+    "openai": {
+        "type": "openai",
+        "base_url": "https://api.openai.com/v1",
+        "api_key_env": "OPENAI_API_KEY",
+        "model": "gpt-4o-mini",
+    },
+    "openrouter": {
+        "type": "openai",
+        "base_url": "https://openrouter.ai/api/v1",
+        "api_key_env": "OPENROUTER_API_KEY",
+        "model": "openai/gpt-4o-mini",
+    },
+    "ollama": {
+        "type": "openai",
+        "base_url": "http://localhost:11434/v1",
+        "api_key_env": None,
+        "model": "qwen2.5-coder:7b",
+    },
+    "anthropic": {
+        "type": "anthropic",
+        "base_url": None,
+        "api_key_env": "ANTHROPIC_API_KEY",
+        "model": "claude-sonnet-4-6",
+    },
+    # Generic OpenAI-compatible endpoint; base_url/model supplied at runtime.
+    "custom": {
+        "type": "openai",
+        "base_url": "http://localhost:8001/v1",
+        "api_key_env": None,
+        "model": "local-model",
+    },
+}
+
+
+# --------------------------------------------------------------------------- #
+# Loading
+# --------------------------------------------------------------------------- #
+def _candidate_paths(explicit: Optional[str]) -> list[Path]:
+    paths = []
+    if explicit:
+        paths.append(Path(explicit))
+    env = os.getenv("EURON_AGENT_CONFIG")
+    if env:
+        paths.append(Path(env))
+    paths.append(Path.cwd() / "config.yaml")
+    paths.append(Path(__file__).resolve().parent.parent / "config.yaml")
+    return paths
+
+
+def _find_config_file(explicit: Optional[str]) -> Optional[Path]:
+    for p in _candidate_paths(explicit):
+        if p and p.is_file():
+            return p
+    return None
+
+
+def _provider_from_dict(name: str, d: dict) -> ProviderConfig:
+    api_key_env = d.get("api_key_env")
+    api_key = os.getenv(api_key_env) if api_key_env else None
+    return ProviderConfig(
+        name=name,
+        type=d.get("type", "openai"),
+        base_url=d.get("base_url"),
+        api_key_env=api_key_env,
+        api_key=api_key,
+        model=d.get("model", "gpt-4o-mini"),
+        temperature=float(d.get("temperature", 0.2)),
+        max_tokens=int(d.get("max_tokens", 4096)),
+        extra_headers=d.get("extra_headers", {}) or {},
+    )
+
+
+def load_config(
+    config_path: Optional[str] = None,
+    *,
+    provider: Optional[str] = None,
+    model: Optional[str] = None,
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+) -> Config:
+    """Load configuration, applying optional overrides.
+
+    `api_key` / `base_url` let a caller (e.g. the VS Code extension) inject a
+    secret and endpoint at runtime so nothing has to live in a file.
+    """
+    raw: dict[str, Any] = {}
+    cfg_file = _find_config_file(config_path)
+    if cfg_file:
+        raw = yaml.safe_load(cfg_file.read_text(encoding="utf-8")) or {}
+
+    # Start from the built-in profiles, then let config.yaml override/extend them.
+    merged: dict[str, dict] = {k: dict(v) for k, v in BUILTIN_PROVIDERS.items()}
+    for name, d in (raw.get("providers", {}) or {}).items():
+        merged[name] = {**merged.get(name, {}), **d}
+    all_providers = {name: _provider_from_dict(name, d) for name, d in merged.items()}
+
+    active = provider or raw.get("active") or "openai"
+    if active not in all_providers:
+        raise ValueError(
+            f"Provider '{active}' not found. Available: {', '.join(all_providers)}"
+        )
+    selected = all_providers[active]
+    overrides: dict[str, Any] = {}
+    if model:
+        overrides["model"] = model
+    if api_key:  # non-empty only
+        overrides["api_key"] = api_key
+    if base_url:
+        overrides["base_url"] = base_url
+    if overrides:
+        selected = replace(selected, **overrides)
+
+    agent_raw = raw.get("agent", {}) or {}
+    agent = AgentConfig(
+        max_steps=int(agent_raw.get("max_steps", 30)),
+        stream=bool(agent_raw.get("stream", True)),
+        auto_approve_reads=bool(agent_raw.get("auto_approve_reads", True)),
+        auto_approve_writes=bool(agent_raw.get("auto_approve_writes", False)),
+        auto_approve_commands=bool(agent_raw.get("auto_approve_commands", False)),
+        max_file_bytes=int(agent_raw.get("max_file_bytes", 120_000)),
+        max_command_seconds=int(agent_raw.get("max_command_seconds", 60)),
+    )
+
+    ignore = raw.get("ignore") or DEFAULT_IGNORE
+
+    return Config(
+        provider=selected,
+        agent=agent,
+        ignore=list(ignore),
+        all_providers=all_providers,
+    )

euron_agent/events.py

@@ -0,0 +1,85 @@
+"""Event protocol and the AgentIO interface.
+
+The agent loop is transport-agnostic: it talks to the outside world only
+through an `AgentIO` implementation. The CLI implements it with the terminal;
+the FastAPI server implements it over a WebSocket. Both speak the same set of
+event dicts so the VS Code webview and the CLI render identical information.
+"""
+from __future__ import annotations
+
+import abc
+from dataclasses import dataclass
+from typing import Optional
+
+
+# --------------------------------------------------------------------------- #
+# Event constructors (plain dicts so they serialize straight to JSON)
+# --------------------------------------------------------------------------- #
+def status(message: str) -> dict:
+    return {"type": "status", "message": message}
+
+
+def token(text: str) -> dict:
+    """A streamed chunk of assistant text."""
+    return {"type": "token", "text": text}
+
+
+def assistant_message(text: str) -> dict:
+    """A complete assistant message (sent once a turn finishes)."""
+    return {"type": "assistant_message", "text": text}
+
+
+def tool_start(call_id: str, name: str, args: dict) -> dict:
+    return {"type": "tool_start", "id": call_id, "name": name, "args": args}
+
+
+def tool_result(call_id: str, name: str, ok: bool, output: str) -> dict:
+    return {"type": "tool_result", "id": call_id, "name": name, "ok": ok, "output": output}
+
+
+def diff(path: str, patch: str, is_new: bool = False) -> dict:
+    return {"type": "diff", "path": path, "patch": patch, "is_new": is_new}
+
+
+def approval_request(call_id: str, name: str, args: dict, preview: Optional[str]) -> dict:
+    return {
+        "type": "approval_request",
+        "id": call_id,
+        "name": name,
+        "args": args,
+        "preview": preview,
+    }
+
+
+def done(summary: str = "") -> dict:
+    return {"type": "done", "summary": summary}
+
+
+def error(message: str) -> dict:
+    return {"type": "error", "message": message}
+
+
+# --------------------------------------------------------------------------- #
+# Approval decision + IO interface
+# --------------------------------------------------------------------------- #
+@dataclass
+class ApprovalDecision:
+    approved: bool
+    feedback: Optional[str] = None  # optional user note fed back to the model
+
+
+class AgentIO(abc.ABC):
+    """How the agent loop emits output and requests human approval."""
+
+    @abc.abstractmethod
+    def on_token(self, text: str) -> None:
+        """Called for every streamed token. MAY be invoked from a worker
+        thread, so implementations must be thread-safe / non-blocking."""
+
+    @abc.abstractmethod
+    async def emit(self, event: dict) -> None:
+        """Emit a structured event (always from the event loop)."""
+
+    @abc.abstractmethod
+    async def request_approval(self, request: dict) -> ApprovalDecision:
+        """Ask the human to approve a gated action and block until answered."""