xera

Appearance

xeraYou write the ticket. Xera writes the test.

Yesterday that was your job — now it's one prompt. Hand a Jira or GitHub ticket to Claude, Cursor, or Codex; Xera writes the spec, runs it, classifies the failure, and posts the verdict back. A live knowledge graph catches breaking changes and surfaces coverage gaps before they ship.

Get started
Try /xera-run on a sample
View on GitHub
xera knowledge graph
🕸️

Project knowledge graph

Tickets ↔ scenarios ↔ POMs ↔ SUT areas ↔ ACs, with an HTML viewer you can attach to any PR. Pre-flight impact analysis before merge — the moat no other QA tool has.

See a live one →

🔍

Diagnoses failures, fixes selectors

A 9-class classifier (REAL_BUG, TEST_BUG, FLAKY, SELECTOR_DRIFT, TEST_OUTDATED, CONTRACT_DRIFT, RATE_LIMITED, AUTH_EXPIRED, PASS) decides what broke — then self-heals: rewrites a drifted locator from the Playwright trace, or a stale API assertion to match the OpenAPI contract, instead of just marking the test red.

📈

Coverage gap & AC matrix

Area-level (UNCOVERED / STALE / COVERED) and AC-level gap reports with risk weighting — plus AI-drafted Gherkin from `/xera-fill-gap` to close the holes.

🌐

Web and HTTP API, one workflow

Playwright adapter for browser flows, dedicated HTTP adapter for API testing — no browser required. Mix both with `xera init --shape mixed`, generate tests straight from an OpenAPI doc (`/xera-feature --from-spec`), and catch CONTRACT_DRIFT on web and API alike.

🔌

Plugs into your stack

Jira (REST or MCP) and GitHub Issues (gh CLI or GitHub MCP) behind one IssueProvider interface. Scaffolds for Claude Code, Cursor, and Codex CLI from a single `xera init`.

⭐

100% open source

Apache 2.0, no SaaS lock-in. Artifacts live in your repo, your CI runs the loop. Star us, file an issue, ship a PR — issues marked "good first issue" are a fast on-ramp.

Star on GitHub →

GitHub starsLicense: Apache 2.0@xera-ai/cli on npmCI statusGood first issues

See it in one line ​

bash
> /xera-run SAMPLE-001
# Reads the acceptance criteria → writes Gherkin + Playwright → runs the test
# → classifies the failure → posts the diagnosis back to Jira or GitHub.

That's the whole loop. Swap SAMPLE-001 for JIRA-123 or GH-42 and Xera works against your real tracker. See it run on FlowBoard →

Quickstart ​

bash
npm install -g @xera-ai/cli         # install once globally; or use npx

mkdir my-tests && cd my-tests
xera init                       # interactive: shape + tracker + ~5 prompts
# or fully non-interactive (GitHub Issues, no token required):
xera init -y --shape web --tracker github \
  --gr xera-ai/xera --su https://staging.example.com

cp .env.example .env            # fill in credentials
npm install
# Web shape only:
npx playwright install chromium
npx xera-internal auth-setup         # pre-authenticate roles

Then in your AI coding agent (Claude Code, Cursor, or Codex CLI):

> /xera-run SAMPLE-001          # web sample
> /xera-run SAMPLE-HTTP-001     # api sample
> /xera-run JIRA-123            # your first real ticket
> /xera-run GH-42               # …or a GitHub issue

Try it on a real app ​

Open in full screen ↗xera knowledge graph viewer — three FlowBoard tickets, their POMs, passing and failing scenarios, and failure classes around the peripheryTap to open the live knowledge graph ↗

There's a complete demo loop you can poke at without writing a single line of code or hosting an app:

RepoRole
xera-ai/xera-sample-appFlowBoard — the SUT. Full-stack project-management app (Fastify + React + SQLite, JWT auth, Swagger REST API, intentional security surfaces).
xera-ai/xera-sample-app-testsReference tests — a working xera consumer project pointed at FlowBoard. Look here for a real xera.config.ts, .xera/<TICKET>/ artifacts, shared POMs, and openapi.json.
xera-ai.github.io/xera-sample-app-testsLive knowledge graph — the actual .xera/graph.html viewer produced from the reference tests above. Click around: tickets ↔ scenarios ↔ POMs ↔ areas, Coverage tab (Map / List / Trend), failure classes.

Spin FlowBoard + the tests up locally:

bash
# 1. Bring FlowBoard up
git clone https://github.com/xera-ai/xera-sample-app
cd xera-sample-app && npm install && npm run dev:backend & npm run dev:frontend
# UI on http://localhost:5173, API on http://localhost:3000

# 2. Clone the reference tests in a sibling directory and run a ticket
cd .. && git clone https://github.com/xera-ai/xera-sample-app-tests
cd xera-sample-app-tests
cp .env.example .env && npm install && npx playwright install chromium
npx xera-internal fetch XFB-6 && npx xera-internal exec XFB-6

Or start from scratch with your own xera project pointed at the same FlowBoard:

bash
mkdir flowboard-tests && cd flowboard-tests
xera init -y --shape mixed --tracker github \
  --gr xera-ai/xera-sample-app \
  --su http://localhost:5173 \
  --au http://localhost:3000

Pair /xera-run with /xera-explore

FlowBoard's intentional surfaces (stored XSS, JWT edge cases, file upload risks, SQL injection points) are exactly the territory the experimental /xera-explore skill brainstorms:

> /xera-run <TICKET>      # AC-driven happy path → test.feature
> /xera-explore <TICKET>  # negative / boundary / race / a11y / security-smell → explore.feature

/xera-explore writes to a separate explore.feature (tagged @adversarial) so PO review of test.feature stays undisturbed.

What you get out of the box ​

SkillWhat it does
/xera-run <TICKET>Full pipeline end-to-end (auto-checks impact after fetch)
/xera-fetch <TICKET>Pull story from Jira or GitHub Issues; extract modified SUT areas
/xera-feature <TICKET>Generate Gherkin (or --from-spec to generate from an OpenAPI doc with no ticket)
/xera-script <TICKET>Generate Playwright spec + page objects
/xera-exec <TICKET>Run the test (supports --grep per-scenario)
/xera-report <TICKET>9-class classifier + post diagnosis to the tracker
/xera-impact <TICKET>Pre-flight: which existing scenarios may break?
/xera-coverageArea + AC-level coverage with risk weighting
/xera-fill-gap <area>AI-drafted Gherkin for UNCOVERED areas or unsatisfied ACs
/xera-explore <TICKET>Brainstorm negative / boundary / race / a11y scenarios
/xera-promote <TICKET> <POM>Move a POM to shared/

Roadmap ​

VersionStatusHighlights
v0.1 – v0.5✅ shippedCore platform, Web adapter, eval harness (/xera-eval), prompt-injection defense, self-healing selectors
v0.6✅ shippedProject knowledge graph, TEST_OUTDATED classifier, /xera-impact, HTML viewer + CI artifact
v0.7✅ shippedHTTP API adapter (@xera-ai/http), pre-auth pattern, CONTRACT_DRIFT / RATE_LIMITED / AUTH_EXPIRED classifiers
v0.8✅ shippedCoverage gap & AC matrix (/xera-coverage, /xera-fill-gap), release infra overhaul (changesets fixed group, auto-changeset from PR titles, xera-automation GitHub App)
v0.9✅ shippedAdversarial exploration (/xera-explore, experimental, opt-in)
v0.10–v0.15✅ shippedMulti-editor support (Claude / Cursor / Codex), cognitive AC extraction from Jira description, xera init --update --shape upgrade path, .d.ts declarations for all packages
v0.16✅ shippedGitHub Issues tracker (xera init --tracker github, no token required), samples remove subcommand
v0.18✅ shippedFeature-from-OpenAPI (/xera-feature --from-spec, no ticket needed), xera init scaffolds a root AGENTS.md
v0.19✅ shippedWeb CONTRACT_DRIFT detection (opt-in xeraNetwork recorder) + self-heal that rewrites a spec.ts assertion to the OpenAPI contract
v1.0🚧 plannedStability commitment (semver from 1.0, frozen TestAdapter interface), public documentation site, cross-adapter graph linkage (endpoint as first-class graph node)
v1.x🔭 planned/xera-sprint multi-ticket orchestration, production trace → test backfill, hosted live dashboard (graph + coverage + disputes), messaging adapters (Kafka, AMQP, WebSocket), GraphQL, gRPC
v2.0🔭 plannedOptional SaaS backend (only if multi-org demand)
Future💡 designed-forMobile, performance, and security adapters — the TestAdapter interface is built to accept them; no timeline or owner yet

Released under the Apache 2.0 License.

Released under the Apache 2.0 License.

Copyright © 2026 xera contributors