Metadata-Version: 2.4
Name: euron-coding-agent
Version: 1.4.0
Summary: Lightweight provider-agnostic agentic coding backend (CLI + server) for the Euron VS Code extension.
Author: Euron Agent contributors
License: Apache-2.0
Project-URL: Homepage, https://github.com/euron-tech/Euron-coding-agent
Project-URL: Issues, https://github.com/euron-tech/Euron-coding-agent/issues
Keywords: ai,agent,coding,llm,cli,vscode
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Operating System :: OS Independent
Classifier: Environment :: Console
Requires-Python: >=3.9
Description-Content-Type: text/markdown
License-File: LICENSE
License-File: NOTICE
Requires-Dist: fastapi>=0.110
Requires-Dist: uvicorn[standard]>=0.29
Requires-Dist: pydantic>=2.6
Requires-Dist: python-dotenv>=1.0
Requires-Dist: pyyaml>=6.0
Requires-Dist: openai>=1.30
Requires-Dist: httpx>=0.27
Requires-Dist: rich>=13.7
Requires-Dist: prompt_toolkit>=3.0
Provides-Extra: anthropic
Requires-Dist: anthropic>=0.34; extra == "anthropic"
Provides-Extra: mcp
Requires-Dist: mcp>=1.0; extra == "mcp"
Provides-Extra: dev
Requires-Dist: pytest>=8.0; extra == "dev"
Dynamic: license-file

# euron-coding-agent

The Python agent backend and standalone CLI behind the Euron Coding Agent VS Code
extension. An open-source, model-agnostic agentic coding assistant that plans,
edits code, runs commands, searches the web, reviews diffs, coordinates teams of
sub-agents, and runs on cron schedules - with your approval at every step.

Provider-agnostic: works with Anthropic, OpenAI, Google Gemini, OpenRouter, Groq,
Cerebras, DeepSeek, Together, Mistral, xAI, Vercel AI Gateway, Euron/Euri,
Ollama, LM Studio, or any OpenAI-compatible / self-hosted endpoint.

## Install

    pip install euron-coding-agent
    euron-agent update                            # update to the latest anytime
    # optional extras:
    pip install "euron-coding-agent[anthropic]"   # native Anthropic client
    pip install "euron-coding-agent[mcp]"         # Model Context Protocol servers

Tip: install into a virtual environment for isolation. The client auto-adapts to
each provider's API (e.g. models needing max_completion_tokens instead of
max_tokens, or rejecting a custom temperature) - no model-specific config needed.

## Quick start (CLI)

    euron-agent                                    # interactive chat in the current folder
    euron-agent run "add a /health route to app.py"
    euron-agent run "summarize the repo" --json     # headless JSON output for CI/scripts
    euron-agent serve --host 0.0.0.0 --port 8000    # self-host with bearer-token auth

Set a provider and key right inside the chat (no files needed):

    you: /provider openai      # or gemini, anthropic, groq, ollama, ...
    you: /key                  # paste your API key (stored in ~/.euron-agent)
    you: create a FastAPI hello-world app with a test

Or use environment variables (OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY,
EURI_API_KEY, ...) or a config.yaml. Built-in provider profiles mean no config
file is required - just pick a provider and supply a key.

## CLI commands

    euron-agent                     interactive chat (remembers provider/key)
    euron-agent run "<task>"        one-shot task ( --yes to auto-approve, --json headless )
    euron-agent providers           list configured providers
    euron-agent models              show the multi-model routing table (per-phase model + price)
    euron-agent init                scaffold config.yaml + .env
    euron-agent serve               run the API / WebSocket server ( --port 0 = auto )
    euron-agent --team-name <name> "<task>"   multi-agent team (coordinator + specialists)
    euron-agent team                list multi-agent teams
    euron-agent schedule create "<name>" --cron "0 9 * * MON-FRI" --prompt "<task>"
    euron-agent schedule list | run <id> | remove <id> | daemon
    euron-agent plugin add <dir|zip-url> | list | remove <name>
    euron-agent security            run a security audit of the codebase
    euron-agent scan                fast secret + dependency vulnerability scan
    euron-agent secfix              autonomous security remediation (audit→fix→verify)
    euron-agent test [--all]        write + run tests (--all = whole-project suite)
    euron-agent ship "<what>"       plan→build→test→scan→deploy→monitor, end to end
    euron-agent deploy [--check]    deploy to a live URL (or list target readiness)
    euron-agent monitor             monitoring status (errors/uptime/providers)
    euron-agent heal [<url>]        self-heal: health-check, auto-rollback, error→PR
    euron-agent doctor              environment self-check
    euron-agent audit [--lines N]   show & verify the tamper-evident action log
    euron-agent init-ci             scaffold a GitHub Actions workflow
    euron-agent sessions            list saved sessions (dashboard)
    euron-agent chat --session <id> | --resume   resume a past session

In-chat commands: /provider /key /model /effort /plan /execute /review /security
/scan /secfix /test /testall /audit /doctor /compact /init /skills /search /usage
/undo /reset /yes /help /exit, plus any custom command in .euron/commands/.

## What's new (1.4.0)

- **The full loop — one sentence to a live, monitored, self-healing app.**
  `euron-agent ship "build a FastAPI todo API with a Neon DB and put it live"` runs
  plan → build → test → security-scan → **deploy** → **monitor**.
- **Auto-deploy** headless to Cloud Run, Cloudflare/Pages, Vercel, Netlify, Render,
  Fly, Railway, Docker, Kubernetes/Helm, AWS (SAM/App Runner), Azure Container Apps,
  plus Neon/Supabase databases — each via its CLI + a credential env var.
- **Spend gate:** free-tier targets deploy directly; billable ones are blocked unless
  you set `deploy.allow_billable`. Secrets are read from env, never printed, and every
  deploy/rollback is recorded in the audit log.
- **Monitoring** (`euron-agent monitor`): wires Sentry / OpenTelemetry / uptime and
  reports current errors + uptime.
- **Self-healing** (`euron-agent heal`): auto-rollback to the last known-good release
  on a failed health check; production errors become a fix + regression test in a PR
  (never auto-merged). See docs/DEPLOY.md.

## What's new (1.3.0)

- **Multi-model routing**: assign a different model (from any provider) to each
  phase — `planner`, `executor`, `cheap` (sub-agents), `verifier` — via `models:` +
  `routing:` in config.yaml. Cost-aware `strategy: auto` runs cheap models where safe
  and **auto-escalates** to a stronger model when the cheaper one keeps failing, so
  you spend the least that still gets the job done. No provider lock-in.
- `euron-agent models` / `/models`: see which model + price runs each phase.
- Cost is now tracked per model actually used. See docs/MULTI_MODEL.md.

## What's new (1.2.0)

- **repo_map** tool: a compact symbol/outline map of the codebase so the agent
  reads outlines first and full file bodies only on demand (token-saving).
- **secret_scan** + **dependency_audit** tools, and **/scan** / **/secfix**
  commands — find hard-coded credentials and vulnerable deps, then remediate in an
  autonomous audit → fix → verify loop.
- **Tamper-evident audit log** (`.euron/audit/`) — SHA-256 hash-chained record of
  every action; `euron-agent audit` / `/audit` verifies the chain.
- **Sandbox / egress policy** (`sandbox:`): deny-by-default command rules, allowlist,
  and `block_network`, enforced before every shell command (even in dangerous mode).
- **Agent-of-agent budgets** (`subagent_max_calls`, `subagent_token_budget`),
  **model routing** (`router: {cheap, heavy}`), an opt-in **verifier** sub-agent
  (`verify_edits`), and **self-heal** (`self_heal: N`).
- **euron-agent doctor** (environment self-check), **init-ci** (GitHub Actions),
  and **Anthropic prompt caching** of the static system prompt.

## What's new (1.1.0)

- Drag-and-drop context: reference or drop a **file, folder, or image** path into
  chat and it is read and used automatically. Files of any reasonable length
  (smart head+tail truncation), folders read recursively, and images sent as
  multimodal blocks so vision models can actually see them. No special syntax -
  quoted paths, absolute/relative paths, bare filenames, and `@mentions` all work.
- Built-in **security audit** (`/security`, `euron-agent security`): vulnerability
  review with severity-ranked findings and concrete fixes.
- **Autonomous testing**: `/test [target]` writes and runs tests for a file/module;
  `/testall` (or `euron-agent test --all`) builds and runs a comprehensive test
  suite for the whole project and reports coverage gaps.
- **Plan mode and execute mode**, switchable mid-session with `/plan` and
  `/execute` (execute is the default).
- Earlier: auto-onboarding (`.euron/` memory + skill + project doc), live status
  line + completion summary, dangerous (YOLO) mode, `/` command autocomplete,
  accurate per-model cost, and memory/context optimization.

## Features

- Auto-onboarding (.euron/ memory + skill + project doc, created automatically).
- Agentic tool-calling loop: plan, read, search, edit, run, verify.
- 28 sandboxed tools: read/write/edit/multi_edit/create/delete files, glob,
  search, run_command (streaming), background processes, git status/diff/commit/
  branch/push, open_pr, git worktrees, web_search, web_fetch.
- Plan mode and execute mode, sub-agents, and multi-agent teams with persistent state.
- Drag-and-drop context: read files (any length), whole folders, and images.
- Full loop: one sentence → build → test → scan → deploy to a live URL → monitor → self-heal.
- Auto-deploy to 13+ targets (Cloud Run/Cloudflare/Vercel/Netlify/Fly/Railway/Render/Docker/K8s/AWS/Azure + Neon/Supabase) with a free-tier-first spend gate.
- Multi-model routing: a different model per phase across providers, cost-aware with auto-escalation.
- Token-friendly code intelligence: `repo_map` outline tool, model routing, prompt caching.
- Security suite: `/security`, `/scan`, `/secfix`, secret_scan + dependency_audit tools.
- Tamper-evident audit log + sandbox/egress policy; sub-agent budgets, verifier, self-heal.
- Autonomous test writing/running (`/test`, `/testall`); `doctor` + `init-ci` helpers.
- Scheduled agents on cron schedules (independent of any terminal).
- MCP servers, plugins, skills, project memory (AGENTS.md), and custom commands.
- Permissions (allow/ask/deny), hooks, approvals with diffs, checkpoints, undo.
- Web search/fetch, multimodal image input, token and cost tracking, extended
  thinking, model fallback chains.
- Messaging notifications: Slack, Discord, Telegram, Google Chat, WhatsApp, Linear.
- Headless JSON mode and a self-hostable server with bearer-token auth.

## Server

- GET  /health      liveness.
- GET  /providers   configured providers.
- POST /agent/run   one-shot, non-interactive (set "auto_approve": true).
- WS   /ws          streaming agent with per-action approval (used by the extension).

The WebSocket init message accepts provider, model, api_key, and base_url so
secrets never need to live on disk. Set EURON_AGENT_TOKEN (or serve --token) to
require bearer auth.

See the project README at https://github.com/euron-tech/Euron-coding-agent for the
full architecture and the VS Code extension.

## License

Apache License 2.0. Copyright 2026 Euron Engage Sphere Technology Private Limited.
