# tabnas

> Seven tools over the tabnas parsing engine: parse, validate, diagnose, fixtures, compare.

- name: dev.tabnas/mcp
- version: 0.1.20
- connection class: R0 (autonomous)
- trust: 99/100
- quality: 79/100 (good)
- owner: not claimed
- descriptor: https://api.protogrid.dev/v1/servers/dev.tabnas%2Fmcp
- tools: https://api.protogrid.dev/v1/servers/dev.tabnas%2Fmcp/tools

**An agent can connect right now, no human step.** Remote endpoint, no authentication, reachable on the last probe.

## Connection (mcpServers)

```json
{
  "mcpServers": {
    "tabnas": {
      "type": "http",
      "url": "https://mcp.tabnas.dev/mcp"
    }
  }
}
```


## Trust

- hygiene: 100
- liveness: 98
- freshness: 100
- provenance: 100
- drivers: +repository +namespace-matches-repo +dns-namespace +website +reachable +uptime-96% +updated-11d-ago
- Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed.

## Quality 79/100 (good)

### protocol: 75 (weight 25)

- warn `protocol.modern`: newest supported version is 2025-06-18; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
- n/a `protocol.stateless`: only applies to 2026-07-28 servers
- pass `protocol.transport`: streamable HTTP
- n/a `protocol.list_ttl`: only applies to 2026-07-28 servers

### authorization: n/a (weight 15)

- n/a `auth.prm`, `auth.as_metadata`, `auth.cimd`: no remote uses OAuth
- n/a `auth.secret_in_url`: no templated URL

### tool hygiene: 71 (weight 30)

- pass `tools.descriptions`: every tool has a description
- pass `tools.description_length`: descriptions are concise
- pass `tools.schemas`: every tool has an object input schema
- fail `tools.annotations`: no tool declares readOnlyHint or destructiveHint, so clients cannot tell safe calls from risky ones
- fail `tools.directory_hints`: no tool declares all four of readOnlyHint, destructiveHint, idempotentHint and openWorldHint; missing: parse (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); list_plugins (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); compare_grammars (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); …
- pass `tools.token_cost`: about 1,340 tokens to load every tool
- pass `tools.api_dump`: tools are not a one-to-one API dump

### stability: 100 (weight 15)

- pass `stability.changes`: no tool changes in 30 days
- pass `stability.rug_pull`: no tool changed its meaning under the same name

### dependencies: n/a (weight 15)

- n/a `deps.known_vulns`, `deps.mcp_sdk_version`, `deps.resolvable`: deps.dev does not know @tabnas/mcp@0.1.20

- tools: 7, about 1,340 tokens to load them all
- tool set hash: 7d504b862ba705c627167620cbf91081
- badge: [![protogrid quality](https://protogrid.dev/badge/dev.tabnas/mcp.svg)](https://protogrid.dev/servers/dev.tabnas/mcp)
- Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed.

### Tool changes

_No tool definition changes recorded._

## Dependencies

- npm @tabnas/mcp@0.1.20: unknown

Dependency graphs from deps.dev; advisories from OSV.dev, including the GitHub Advisory Database and the PyPI Advisory Database; all CC BY 4.0.

## Remotes

- https://mcp.tabnas.dev/mcp (streamable-http, auth none, reachable true, uptime30d 0.95535713)

## Packages

- npm @tabnas/mcp@0.1.20

## Tools (7)

- `compare_grammars`: Grammar compatibility (AX plan Phase 5): does candidate grammar B still accept what baseline A accepted, and does it build the same tree for inputs both accept? Returns EVIDENCE AND CONFIDENCE, never a bare verdict: {normalForm, proven[], observed[], changes[], counterexamples[], confidence, why}. confidence:'low' with a stated reason is a successful run, not a failure — language inclusion is undecidable in general, so anything outside the decidable subset is reported not-proven rather than incompatible. Supply `corpus` (real inputs) for the tier that measures what your documents actually do.
- `describe_plugin`: The full descriptor for one plugin, by package name ('@tabnas/csv') or bare fleet name ('csv'). Unknown names get {ok:false, errors} naming the known plugins.
- `explain_parse_error`: Parse input and explain the failure. Returns {failed:false} when the input parses; otherwise {failed:true, diagnostic, registry} where registry is the error-code registry entry {code,message,hint} for the diagnostic code (resource tabnas://errors), or null for a code the bundled registry does not know (e.g. a plugin-declared code).
- `list_plugins`: List every bundled tabnas plugin descriptor (tabnas.plugin.json of each fleet repo), sorted by name. Returns {plugins:[...]}.
- `parse`: Parse input with the tabnas engine. Returns {ok:true, tree} or, on parse failure, {ok:false, diagnostic} — the structured diagnostic described by resource tabnas://schema/diagnostic. An invalid grammar is rejected as {ok:false, errors:[{path,message}]}. Without a grammar the bare engine is used, which defines no rules and produces an undefined tree for every input.
- `test_grammar`: Run TSV fixture content against a grammar in a fresh instance, using the fleet fixture convention (@tabnas/support): line 1 is a header, the input column is escape-decoded, the expected column is JSON or ERROR / ERROR:<code>. Returns {pass, fail, rows:[{row,input,expected,got,ok}]}. Refuses more than 10000 rows.
- `validate_grammar`: Validate a serialized GrammarSpec. Structural validation against the bundled grammar schema, an engine load in a fresh instance, and a check that every rule reference (`p`, `r`) names a rule the grammar actually defines — a dangling reference loads cleanly and then fails at parse time with `unknown_rule`. Returns {ok:true, v} (v = declared builtin config-schema version, absent means 1) or {ok:false, errors:[{path,message}]}. Security: a grammar carrying a `ref` key, or any function reference that is not a $-suffixed engine builtin, is rejected — validating a grammar never runs supplied code.