Tavero

io.github.baccaraaaPublished by GitHub account baccaraaav0.7.0Updated Nov 2, 2026

Finds UI drift in React apps (buttons, cards, colors, spacing) and gives your agent each fix

Overview

AI-generated overview

Scans a running React app in a real browser to find UI drift in buttons, cards, colors and spacing, and hands the coding agent each fix with file, line and…

What you can do
  • Read a compact design-system brief before writing UI, plus the project's design tokens with source locations
  • List UI consistency findings worst first, and open one finding with paged evidence: current value, expected token or component, file:line and crop paths
  • Browse the React component inventory, inspect one component, and get absolute paths of PNG crops showing how it renders
  • Run a browser scan at mobile, tablet and desktop widths (plus a dark pass), optionally limited to specific routes and rules
  • Compare the latest scan with the previous one to see findings that are new, resolved or unchanged
When to use it
Useful when an agent edits UI in a React 19 app on Vite or Next and you want it to reuse existing components and tokens instead of inventing new styles, and to verify a fix by rescanning a route.
Requirements
Runs locally over stdio as an npm package (tavero) on Node 20 or later, with Chromium installed via Playwright. Needs a React 19 app in dev mode on Vite or Next, and a reachable dev server URL; a one-time login command if the app requires authentication. No account, API key or environment variable is declared.
Before you install
The scan opens the app in Chromium and logs in with your credentials if you provide a login, so it sees whatever the app renders. It writes only to the project's .tavero directory, including decisions.json, which the README suggests committing. Scans take minutes and card detection is heuristic. The README states it runs locally and sends nothing anywhere.

Installation

In SourceWeft

  1. Open Tavero in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

[Tavero]

Tavero

Keep the UI your agent writes consistent.
taveroui.com · Docs · Demo

[CI] [MIT license] [Node 20 or later] [React 19]

Tavero scans your running React app, finds drift in buttons, cards, colors and spacing, and gives your coding agent each fix with the file, the line and the token to use. It runs on your machine, as a CLI, an MCP server for Claude Code, Cursor, Codex and other agents, and a local panel where you decide what is intended.

[A Tavero finding on the Acme demo: 7 text button styles, each with its crop, component, file and line, and the canonical Button chosen in the panel]

A real finding from the Acme demo in this repository (demo/acme): six pages scanned at three widths.

How it works

  1. Scan. Tavero opens your dev server in Chromium at mobile, tablet and desktop widths, with your login if the app needs one. If the project styles a dark theme, it adds one dark pass.
  2. Attribute. Every visible element is mapped to the React component and the source line that rendered it, from React's own dev-mode data. Nothing is added to your project.
  3. Find. Four rules compare what renders with your tokens and with itself: buttons, cards, colors and scales.
  4. Fix. Each finding is a task: what, where (file:line), the current value, and the token or component expected. Your agent fixes it, rescans one route in seconds, and checks that the finding is resolved.

Quick start

Node 20 or later, a Vite or Next app on React 19 that runs in dev mode.

bash
npm i -D taveronpx playwright install chromium                      # once per machinenpx tavero login --url http://localhost:5173/login   # once, if the app has a loginnpx tavero scan --url http://localhost:5173npx tavero findings
id            sev     rule     decision  title                                                         evidencef_c75ac3d6a2  high    buttons            7 text button styles                                          7f_36cb934b5e  high    scales             13 distinct padding values, 1 declared                        12f_94269275c1  medium  buttons            Two text button styles differ only in radius, paddingY, pa…   2f_057122e1f9  medium  buttons            4 place(s) write <button> directly in page or section mark…   4… 30 more, use --page 2
bash
npx tavero finding f_ff30adc07c   # evidence: file:line, current value, expected token, cropsnpx tavero context                # a ~1,500-token brief of the design system for an agentnpx tavero report                 # a self-contained HTML report

Tavero writes only to <project>/.tavero/. Every read command takes --json, and text output is capped at 20 rows so it fits an agent's context.

Use it from your agent

tavero mcp is an MCP server on stdio with nine tools. Print the config for your client and paste it where it says:

bash
npx tavero mcp --print-config claude       # Claude Code: .mcp.jsonnpx tavero mcp --print-config cursor       # .cursor/mcp.jsonnpx tavero mcp --print-config codex        # .codex/config.tomlnpx tavero mcp --print-config gemini       # .gemini/settings.jsonnpx tavero mcp --print-config antigravity  # .agents/mcp_config.jsonnpx tavero mcp --print-config vscode       # .vscode/mcp.json (GitHub Copilot)npx tavero mcp --print-config windsurf     # ~/.codeium/windsurf/mcp_config.json

Then paste docs/AGENTS.snippet.md into AGENTS.md, CLAUDE.md or GEMINI.md, so the agent reads the design context before writing UI. SKILL.md is an Agent Skill with the full workflow.

A recorded run of Claude Code on the Acme demo, with no shell, 29 seconds:

› tavero_context  Action button is Button from src/components/Button.tsx (props: variant)› tavero_findings rule=colors  f_ff30adc07c  Color #4263eb is not a project token› tavero_finding f_ff30adc07c  src/app.css:33  literal #4263eb in source  expected  --acme-primary #3b5bdb (ΔE 3.5)  edit src/app.css:33  background: #4263eb → var(--acme-primary)› tavero_scan routes=/billing rules=colors› tavero_diff  resolved  f_ff30adc07c  Color #4263eb is not a project token  resolved  f_18862a0332  Hardcoded color #4263eb in 1 place(s)  new  0
ToolUse
tavero_contextdesign-system brief; call before writing UI
tavero_findings, tavero_findingproblems, worst first; one problem with evidence, the expected value and the exact rescan call
tavero_scanscan the app; after a fix, only the touched routes and rules. Streams progress, cancellable
tavero_diffresolved, new and unchanged findings since the previous scan
tavero_components, tavero_component, tavero_show, tavero_tokensinventory, crop paths, tokens

Rules

RuleReports
buttonsdistinct text and icon button styles with the components that render them, near-duplicate pairs, <button>s written outside button components
cards (preliminary)distinct card styles, near pairs, card-like containers built inline
colorscolors outside your tokens with the nearest token and ΔE, Tailwind default colors in a project with its own palette, near-identical pairs, hardcoded literals with file and line; in a dark theme, backgrounds that stay light, dark text on a dark page and dark-only colors without a token
scalesradius, padding, gap, font size, weight and shadow values off the scale your tokens declare

Decide what is intended

bash
npx tavero ui --open   # http://127.0.0.1:4747

[The Tavero panel: a list of findings and, for the button styles finding, every variant with its crop at three widths and a choice of the canonical one]

A local panel for the person behind the agent. Go through the findings with the keyboard and decide. The agent sees each decision on its next call, without a rescan.

DecisionWhat the agent sees
Fixthe finding comes first, marked as confirmed work
Intendedhidden until the finding gains new places
Canonicalon button and card variants: the reference variant and allowed ones, optionally named ("primary", "ghost"); the others get it as expected
Notea message delivered with the finding

Decisions are stored in .tavero/decisions.json, keyed by stable finding ids. Commit it to share them with your team and its agents. npx tavero ui --export ./panel writes a static, read-only copy of the panel.

Requirements and limits

  • React 19 in dev mode, on Vite or Next (App Router, Turbopack). React 18 keeps different debug data and is not supported yet.
  • Tokens are read from CSS custom properties and Tailwind 3 or 4 themes.
  • Card detection is heuristic, so the cards rule is marked preliminary.
  • Tavero runs locally and sends nothing anywhere. There is no account and no telemetry.

Development

bash
npm cinpx playwright install chromiumnpm test             # unit and Playwright runtime tests; starts the test apps itselfnpm run typechecknpm run build

The website lives in site/ (Next.js static export). npm run site:install && npm run site:dev runs it; npm run site:audit runs its gates: Tavero on the site itself with 0 high and medium findings, Lighthouse, axe and three widths.

src/  core/      scan orchestration, aggregates, query API, decisions, diff, stable ids  project/   framework detection  static/    tokens, Tailwind theme and palette, hardcoded colors, component index  runtime/   dev server, session, crawl, in-page collector, attribution, crops  rules/     signatures and the four rules  context/   the agent-facing brief  report/    HTML report  mcp/       MCP server, tools, client configs  ui/        local panel and static export  cli/       the command linedemo/acme/   a small dashboard with deliberate drift, used by tests and the websitetest/        unit and runtime tests with mini Vite and Next appsdesign/      design tokens shared by the panel and the websitesite/        the website

See CONTRIBUTING.md before opening a pull request.

License

MIT

Source: README.md at commit 1289724

Tools

9

tavero_context

Design-system brief

Compact Markdown brief of this React app's design system: stack, tokens, the canonical button/icon-button/card components with files and props, dominant radius/spacing/typography, and open problems. Call it BEFORE writing or changing UI, then reuse the components and tokens it names instead of inventing styles.

Parametersbudget

tavero_findings

List findings

UI consistency problems of the latest scan, worst first: distinct button and card styles, colors outside the tokens, Tailwind defaults, hardcoded literals, off-scale radius/spacing/typography. Each row has a stable id, severity, rule, title and evidence count; evidence is not included. Filter by rule or severity; paginate with limit/page. Open one with tavero_finding. A human may have triaged findings in the Tavero panel: `decision.status` fix means confirmed work (listed first), findings marked accepted are hidden, `decision.note` is a message to you.

ParameterspagerulelimitdecisionseverityincludeAccepted

tavero_finding

One finding with evidence

One finding with paged evidence rows: current value, `expected` (the project token or canonical component to use instead, or a note that no close token exists and one should be added), component, file:line, route/viewport and a crop image path. Rows valued "literal … in source" are where the value is written (often CSS); the other rows are where it renders (the component JSX). Fix the code using `expected`, then rescan only the affected routes with tavero_scan (routes + rules) and confirm with tavero_diff.

ParametersidrequiredevidencePageevidenceLimit

tavero_components

List components

React components seen in the latest scan with instance counts, pages and source file:line. Search by name or file with `query`; sort by instances (default) or name; `unresolved` lists components without a source file.

Parameterspagesortlimitqueryunresolved

tavero_component

Component details

One component by id or name: source file:line, prop names, instance count, which pages and viewports render it, and crop image paths.

ParametersidOrNamerequired

tavero_show

Crop image paths

Absolute paths of PNG crops showing how a component actually renders, optionally for one viewport. Open them with your image/file reader to see the component.

ParametersidOrNamerequiredviewport

tavero_tokens

Design tokens

Design tokens found in the app (CSS custom properties and Tailwind theme): name, kind, raw and resolved value, source file:line. Use these names instead of literal colors and sizes.

Parameterskindpagelimit

tavero_diff

Diff two scans

Findings that are new, resolved or unchanged (with changed stats) between the previous and the latest scan, by stable id. A finding is fixed when it is listed under resolved. After a partial rescan, `note` says how many routes were not rescanned and may still carry the finding.

Parameterstofrom

tavero_scan

Scan the running app

Crawl the app in a real browser at mobile/tablet/desktop widths (plus one dark-theme pass at desktop width when the project styles a dark theme), map every element to its React component and file:line, and recompute findings. A full scan takes minutes; after a code fix pass only the affected `routes` and the finding's `rules` (seconds) — findings on other routes are carried over. Needs the dev server url (it is started with `npm run dev` if nothing answers and kept running for later scans). Then call tavero_diff.

Parametersurlrequiredrulesroutesviewports

Version history

3
  1. v0.7.0LatestOct 26, 2026
  2. v0.6.0Oct 25, 2026
  3. v0.5.1Oct 24, 2026

Score

90% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 days25 pts
  • Auth declared10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts