# Jarroba Tools

> Around a hundred developer and learning tools that run **entirely in the browser** — no server,
> no account, no data leaving the device. Several of them accept a **machine-readable input format
> designed for an AI to write** and a person to paste. This file is the index of those formats.

**If you are an AI and a person asked you to produce something for one of these tools, read the
format document for that tool below.** Each one is a single self-contained page: what the format
is, every field, worked examples, and the mistakes that matter. They are all in English.

Every path here is relative to the app root you are already reading this from — for example
`https://jarroba.com/tools/en/llms.txt` sits next to `https://jarroba.com/tools/en/jtd.md`. The
same files are served under every language folder (`/es/`, `/en/`, `/de/`, `/pt/`, `/fr/`) and are
**identical**: the documents themselves are always English, only the tools' interface is translated.

## Authoring formats

- [jtd.md](jtd.md): **JTD** (Jarroba Tools Diagram) — high-level JSON for **any** diagram: flow
  charts, org charts, mind maps, timelines, architectures, cards/dashboards and charts (bar, line,
  pie, radar…). Compiles to a **fully editable** diagram, not a picture. Paste it into the "Import
  Mermaid/JTD" box in the Diagrams tool (the same box also takes Mermaid).
  With `frames` it also describes **animations**: a movie inside the page, frame by frame, with morph/fade transitions and a zooming camera.
  Schema: [jtd.schema.json](jtd.schema.json). Validator + live preview: [jtd](jtd).
- [logprofile.md](logprofile.md): **Log profile** — short JSON describing what one team's logs look
  like (format, server time zone, your own code's prefix, what counts as noise, and the token
  budget for the AI-oriented reduction). Paste it into the "Log profile" box in the Logs tool.
  Schema: [logprofile.schema.json](logprofile.schema.json).
- [kg.md](kg.md): **Knowledge graph** — RDF (Turtle recommended, plus JSON-LD, N-Triples, N-Quads,
  TriG, RDF/XML) to visualise and query with SPARQL 1.1, optionally with a light RDFS ontology and
  a semantic layer of named metrics. Paste it into the Data tab of the Knowledge Graph tool.
- [access.md](access.md): **Access Lab world** — a JSON object describing an identity/RBAC setup
  for Azure RBAC, AWS IAM/Organizations, GCP Resource Manager or Kubernetes RBAC (pick one), every
  field shape and rule cited against the official docs. Paste it into the "World (JSON)" box of the
  Import tab in the Access Lab tool, or pass it as `world` to `access_check`.
- [escenario-auth.md](escenario-auth.md): **Authentication scenario** — a JSON object describing an
  editable auth flow (actors, connections, an ordered script of steps, and attacks that point at a
  step or an actor) for the Authentication Flow Lab. Real Web Crypto runs it: the signatures and
  verifications are genuine. Paste it into the "Import scenario" box in the Authentication Flow tool.
- [archsim.md](archsim.md): **Architecture simulation** — a JSON object with the components of a
  system (clients, gateways, services, queues, caches, databases, AI…) and their numbers (capacity,
  latency, queue size, cache hit ratio, partitions…). The Architecture Simulator runs traffic through
  it: throughput, p50/p95, availability, queue lag, silently lost messages, bottleneck and cost.
  Paste it into "Paste JSON (AI authoring)" in the Architecture Simulator, or press Ctrl+V on its canvas.

## How to check your own work

**You cannot judge a diagram, a profile or a graph by reading the JSON you just wrote.** Every
format above has a way to run it before you hand it over, and using it is the difference between
getting it right and guessing:

- **In the browser, with nothing installed**: the Diagrams tool ships a validator and live preview
  at [jtd](jtd) — paste the JSON and see the drawing. The other tools validate on paste and report
  the exact field that is wrong.
- **Over MCP**: there are **local MCP servers** (stdio, no network, nothing leaves the machine) that
  reuse the very same code the web tools run, so the answer is identical. Install with
  `npx -y @jarroba/mcp` (everything, 128 tools) or one of the focused ones —
  `npx -y @jarroba/mcp-logs` (11 tools), `npx -y @jarroba/mcp-tests` (4 tools) and
  `npx -y @jarroba/mcp-calc` (5 tools) — which cost far less of your context. For the formats above the relevant tools are `diagram_validate` and `diagram_svg`
  (it hands the drawing back, so you can look at it and fix it), `log_profile_check` and
  `log_profile_suggest` (both accept a **file path**), `kg_query`, `kg_validate`,
  `kg_semantic_validate` and `kg_metric`, `access_check`, `access_who_can` and `access_diff`, and
  `archsim_validate` and `archsim_simulate` (it runs the architecture and returns throughput, latency,
  queue lag, lost messages, bottleneck and cost, so you can fix the design before handing it over).

  Two of those servers do something the web cannot, and it is worth knowing they exist:
  **the log tools take a file path**, so you can ask about a 200 MB CI log that will never fit in
  your context; and **the test tools audit tests**, including whether a change you just made
  *weakened* the suite. If you have been told to make tests pass, run `test_diff_audit` on your own
  diff before claiming you are done — widening a matcher is cheaper than fixing the bug, and that is
  exactly what it checks for.

Each tool page also has a **"Copy prompt for AI"** button that produces a ready-made prompt with
absolute URLs to the document, the schema and the validator. If a person is helping you, that is
the shortest path.

## Registers you can read

- [practicas.json](practicas.json): **the practices register** — whether a development or AI practice
  you learned in training still holds: still valid, superseded (and by which), anti-pattern,
  unnecessary, or depends on the case, each with **when** it changed, how sure we are (measured,
  documented by the primary source, consensus, opinion) and the literal quote of its source. It is the
  data behind the [practices](practices) page; `?q=<id>` links one entry. Read each entry's `historia`
  by `fecha` (when it changed in the world): a milestone with `tipo: "anuncio"` was only announced and
  `tipo: "borrador"` is a draft — neither one changed the verdict. Field names are Spanish; every
  text comes in `es` and `en`. **No entry means not reviewed here**, not that the practice is fine.
  Over MCP the same register answers `practice_check(topic, since)`: give it your knowledge cutoff as
  `since` and it returns only what changed after it (in `@jarroba/mcp`).

## Ground rules for these formats

1. **Return only the document.** No prose around it, no fences. It gets pasted verbatim.
2. **Leave out what you do not know.** A missing optional field keeps the default; an invented one
   misconfigures the tool without anybody noticing.
3. **Iterate against the validator**, do not hand over a first draft you have not run.
4. **Nothing here calls an external AI provider.** These tools run models locally in the browser
   when they use one at all. Do not assume a server-side step exists.