Skip to main content
Glama
mcp-repo-release-tools

mcp-repo-release-tools

Does the code still match its declared architecture?

rrt_arch_check
Read-onlyIdempotent

Validate the repository tree against architecture rules and the findings baseline to surface new, baselined, or stale violations before adding modules, imports, or opening a PR.

Instructions

Check the tree against [tool.rrt.architecture] and its findings baseline.

Use before adding a module, a unit or a cross-unit import, and before a PR: the rrt-arch-check hook runs the same check with strict=True. Each finding is new (not in .rrt/architecture.baseline.toml), baselined, or stale (recorded but resolved). exit_code matches rrt arch check. Pass check_templates=True to also self-test every .rrt/templates/ kind. Read-only: never writes the baseline or renders templates; rrt arch baseline and rrt arch new stay CLI-only.

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "rrt_arch_check"
  }
}

Input Schema

NameRequiredDescriptionDefault
rootNo
strictNo
check_templatesNo

Output Schema

NameRequiredDescriptionDefault
okYes
rootNo
errorNo
strictYes
baselineNo
findingsNo
exit_codeYes
new_countNo
templatesNo
stale_countNo
baselined_countNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. Addedv1.20.0

TDQS

A4.3/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The annotations already mark the tool read-only and idempotent, and the description still adds meaningful information: what each finding status means, and that `exit_code` mirrors `rrt arch check`, which tells the agent that a nonzero result signals a real problem. It also states explicitly that the tool never writes the baseline or renders templates, which reinforces the read-only annotation. Return shape is deferred to the output schema, so that is not a gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with its core purpose and packed efficiently, with each sentence carrying either usage timing, finding vocabulary, or the read-only boundary. Some density (backticked flags, baseline filename, hook name) makes it scannable only to readers familiar with the repo, but no sentence is filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a three-parameter checker with an output schema, this covers what an agent needs: when to run it, how to read the findings and exit code, and what it will not do. The only real hole is the undocumented `root` parameter, which matters because the schema explains none of the parameters.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must carry the full burden; it explains `check_templates=True` (it self-tests every .rrt/templates/ kind) and implies `strict` through the hook comparison, but the `root` parameter is never mentioned, so its meaning remains undocumented. The coverage is better than the schema alone, but it is incomplete.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description specifies both the verb and the resource: 'Check the tree against [tool.rrt.architecture] and its findings baseline.' It also states the finding taxonomy and the exit-code contract, so an agent can tell this architectural check apart from the sibling checks (docs, folder, release, sync).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description states exactly when to call the tool ('before adding a module, a unit or a cross-unit import, and before a PR'). It also clarifies the division of labor: the `rrt-arch-check` hook runs the same check with strict=True, and `rrt arch baseline` / `rrt arch new` are CLI-only, so it says when not to expect this tool to do those things.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.