Skip to main content
Glama
Trestle MCP

Trestle MCP

Official

Trestle MCP

MCP server to easily use compliance-trestle (OSCAL tool) from OpenCode, Claude, or any MCP-compliant client.

mcp-name: io.github.oscal-compass/compliance-trestle-mcp

Getting Started

This project can be used in the following two ways:

Choose the option that best fits your workflow.

Related MCP server: MCP REST API Server

Usage from OpenCode

  1. Add the following to opencode.json in your workspace:

    {
        "mcp": {
            "trestle": {
                "type": "local",
                "command": ["uvx", "--from", "compliance-trestle-mcp==<version>", "trestle-mcp"],
                "environment": { "TRESTLE_MCP_TOOLS": "all" },
                "enabled": true
            }
        }
    }

    Replace <version> with the release you want; drop ==<version> to track the latest. TRESTLE_MCP_TOOLS chooses how much of the command surface to expose — all is every tool, and the default without it is the authoring lifecycle. See Choosing which tools are exposed.

  2. Open OpenCode, confirm the trestle tools are listed, and execute as needed.

    https://github.com/user-attachments/assets/a85b0927-4981-41d1-9a03-f22becb7a6e2


Usage from CLI (MCP Client)

Step 1: Write your mcp.json config

{
    "mcpServers": {
        "trestle": {
            "command": "uvx",
            "args": ["--from", "./trestle-mcp-tmp", "trestle-mcp"]
        }
    }
}

Save this as mcp.json in your current directory.

Step 2: List Available Tools

uvx mcp-cli tools --config-file mcp.json

Sample output (tools available):

13 Available Tools
┌─────────┬───────────────────────────────────┬───────────────────────────────────────────────────────────────────┐
│ Server  │ Tool                              │ Description                                                       │
├─────────┼───────────────────────────────────┼───────────────────────────────────────────────────────────────────┤
│ trestle │ trestle_init                      │ Initialize a trestle working directory.                           │
│ trestle │ trestle_import                    │ Import an existing OSCAL model into the trestle workspace.        │
│ trestle │ trestle_validate                  │ Validate a standalone OSCAL file against the OSCAL schema.        │
│ trestle │ trestle_author_catalog_generate   │ Generate Catalog controls in markdown form from a catalog.        │
│ trestle │ trestle_author_catalog_assemble   │ Assemble markdown files of controls into a Catalog json file.     │
│ trestle │ trestle_author_profile_generate   │ Generate markdown documentation set for controls in a profile.    │
│ trestle │ trestle_author_profile_assemble   │ Assemble markdown controls into a Profile JSON file.              │
│ trestle │ trestle_author_profile_resolve    │ Resolve an OSCAL profile to a resolved profile catalog.           │
│ trestle │ trestle_author_component_generate │ Generate component markdown from a component-definition.          │
│ trestle │ trestle_author_component_assemble │ Assemble markdown controls into a component-definition json file. │
│ trestle │ trestle_task_csv_to_oscal_cd      │ Convert a CSV file to an OSCAL component definition.              │
│ trestle │ trestle_task_csv_to_oscal_mc      │ Convert a CSV file to an OSCAL mapping collection.                │
│ trestle │ trestle_task_xlsx_to_oscal_poam   │ Convert a FedRAMP XLSX spreadsheet to an OSCAL POA&M.             │
└─────────┴───────────────────────────────────┴───────────────────────────────────────────────────────────────────┘

Those 13 are the default selection. The server implements 29 tools in all: 28 that groups can select, plus trestle_remove, which is registered only when named explicitly. See Choosing which tools are exposed, and Commands deliberately not covered for the parts of the trestle CLI that have no tool and why.

Step 3: Execute a Tool (e.g., trestle_init)

Start MCP interactive shell:

uvx mcp-cli interactive --config-file mcp.json

Then run, for example:

> execute trestle_init '{"params": {}}'

Typical result:

✓ ✅ Tool executed successfully
{
  "result": {
    ...
    "content": [
      {
        "type": "text",
        "text": "✅ Trestle workspace initialized successfully"
      }
    ]
  }
}

You'll see folders as follows:

assessment-plans    catalogs               plan-of-action-and-milestones  system-security-plans
assessment-results  component-definitions  profiles

Choosing which tools are exposed

Every tool a server registers costs the caller context: an MCP client loads each tool's name, input schema and description into the model's context window on every session. This server covers the trestle command surface an agent should drive, but exposes only the authoring lifecycle unless you ask for more, so a session carries the part of that surface it will actually call and the rest is one setting away.

The selection is a comma-separated list of group names and/or individual tool names, read from the --tools flag or the TRESTLE_MCP_TOOLS environment variable. The flag wins over the environment variable. Naming something that does not exist fails at startup with the list of valid names, rather than starting up with the tool quietly missing — and the flag has to be spelled in full, so a config file carrying --tool is rejected instead of guessed at.

Value

Tools

tools/list chars

Meaning

authoring

13

47,342

The curated authoring lifecycle. The default.

core

12

39,668

The top-level trestle commands

author

11

39,684

Every trestle author subcommand wrapper

task

5

20,318

Every trestle task wrapper, including the generic runner

all

28

99,668

Everything a group can select

trestle_author_ssp_generate

1

4,630

Any single tool, by its registered name

The default is less than half the size of all, and selections combine, so you pay only for what you name. Measure any selection yourself with python scripts/tool_context_cost.py; see What each tool selection costs in context for the current figures per selection and per tool, and for how to narrow the default further.

core, author and task mirror the trestle CLI's own command structure, so which tool is in which group follows from the CLI. authoring is the one curated preset that cuts across them.

Tools no group selects. trestle_remove deletes an element from a model in place, with no backup, so no group selects it — all included. It is registered only when the selection names it exactly, e.g. authoring,trestle_remove.

Default (the authoring lifecycle) — no configuration needed:

{
    "mcpServers": {
        "trestle": {
            "command": "uvx",
            "args": ["--from", "compliance-trestle-mcp", "trestle-mcp"]
        }
    }
}

Everything, via the environment variable:

{
    "mcpServers": {
        "trestle": {
            "command": "uvx",
            "args": ["--from", "compliance-trestle-mcp", "trestle-mcp"],
            "env": { "TRESTLE_MCP_TOOLS": "all" }
        }
    }
}

A mixed selection, via the flag — the authoring lifecycle plus SSP generation and the generic task runner:

{
    "mcpServers": {
        "trestle": {
            "command": "uvx",
            "args": [
                "--from", "compliance-trestle-mcp", "trestle-mcp",
                "--tools", "authoring,trestle_author_ssp_generate,trestle_task_run"
            ]
        }
    }
}

The examples above use the mcpServers shape most MCP clients take. OpenCode spells the same things differently — mcp rather than mcpServers, command as one array instead of a command plus args, and environment rather than env — so the "everything" selection looks like the entry at the top of this README.

Run trestle-mcp --help for the group list, and watch stderr on startup for the line reporting the selection and how many tools it registered.

Tool List & Quick Reference

Tools marked (default) are in the authoring preset.

core — top-level trestle commands

  • trestle_init (default): Initialize a trestle workspace

  • trestle_import (default): Import OSCAL models (Catalog/Profile/etc.) from a file or URL

  • trestle_validate (default): Validate a standalone OSCAL file (any top-level model, e.g. POA&M) against the OSCAL schema (and trestle's semantic checks)

  • trestle_create: Create a sample OSCAL model, or a new element inside an existing model file

  • trestle_assemble: Assemble a split model into a single file under dist

  • trestle_split: Split subcomponents of a model into separate files

  • trestle_merge: Merge split subcomponents back into a model

  • trestle_describe: Describe the contents of a model file, optionally at an element path

  • trestle_replicate: Copy a top-level model to a new name, optionally with fresh uuids

  • trestle_href: List or repoint the import hrefs of a profile

  • trestle_partial_object_validate: Validate a single OSCAL object held in a file

  • trestle_version: Report the trestle and OSCAL versions, or a model's own document version (metadata.version, not its OSCAL version)

author — trestle author subcommands

  • trestle_author_catalog_generate (default): Generate markdown controls from a catalog

  • trestle_author_catalog_assemble (default): Assemble markdown controls back into a catalog JSON

  • trestle_author_profile_generate (default): Generate markdown for profiles

  • trestle_author_profile_assemble (default): Assemble markdown controls into profile JSON

  • trestle_author_profile_resolve (default): Resolve a profile to a catalog

  • trestle_author_profile_inherit: Derive a profile from a parent profile and a leveraged SSP

  • trestle_author_component_generate (default): Generate markdown from a component definition

  • trestle_author_component_assemble (default): Assemble markdown back into a component definition

  • trestle_author_ssp_generate: Generate SSP markdown from a profile and component definitions

  • trestle_author_ssp_assemble: Assemble SSP markdown into a system-security-plan JSON

  • trestle_author_ssp_filter: Filter an SSP by profile, components, implementation status or control origination

task — trestle task wrappers

  • trestle_task_csv_to_oscal_cd (default): Convert a CSV mapping file into an OSCAL component definition

  • trestle_task_csv_to_oscal_mc (default): Convert a CSV crosswalk into an OSCAL mapping collection

  • trestle_task_xlsx_to_oscal_poam (default): Convert a FedRAMP-format XLSX spreadsheet into an OSCAL Plan of Action and Milestones (POA&M)

  • trestle_task_list: List the available trestle tasks, or describe one task's configuration keys

  • trestle_task_run: Run any trestle task from a configuration dictionary

trestle_task_run covers every task the installed trestle provides, including ones with no typed tool here. Prefer the typed tools where they exist: they validate their arguments and document the input format.

Not covered

The signing and provenance commands (sign, verify, generate-manifest, sign-manifest, verify-manifest, canonicalize), the beta feature-flag command, and the markdown governance commands (author docs, author folders, author headers, author jinja) have no tools here. The reasons are recorded in the development guide.

For advanced use, refer to the official compliance-trestle docs; to add or change a tool here, see the development guide.

Troubleshooting & Help

  • Make sure uvx is installed and on your PATH.

  • If you see command/module errors, check the MCP server path in mcp.json is correct.


We are a Cloud Native Computing Foundation sandbox project.

The Linux Foundation® (TLF) has registered trademarks and uses trademarks. For a list of TLF trademarks, see Trademark Usage.

OSCAL Compass is an independent open source project. It is not affiliated with, endorsed by, or sponsored by the National Institute of Standards and Technology (NIST) or any other government agency.

OSCAL Compass was originally contributed by IBM.

Available Tools

13 tools
trestle_author_catalog_assembleAssemble Catalog JSON from MarkdownA
Destructive

Assemble markdown files of controls into a Catalog json file.

This is the return leg of the catalog authoring round trip: run trestle_author_catalog_generate to get markdown, edit the control prose or the yaml header, then run this tool to write the edits back into catalogs//catalog.json.

Set set_parameters when the edits include parameter values or properties in the markdown yaml header — without it only the control prose is read back, and header edits are silently discarded.

Args: params (TrestleAuthorCatalogAssembleInput): Input parameters with: - markdown (str): Input markdown control directory (required) - output (str): Output json catalog name (required) - name (Optional[str]): Source catalog model name (defaults to output) - set_parameters (bool): Read parameters and properties from the markdown yaml header (default: false) - regenerate (bool): Force generation of new uuids (default: false) - version (Optional[str]): New version for the assembled model - trestle_root (Optional[str]): Trestle workspace root path - verbose (bool): Display verbose output

Returns: str: Success or error message

Examples: - Use when: "Write my markdown control edits back into the catalog json" - Use when: "Assemble a catalog from markdown and stamp it version 1.1.0" - Don't use when: The markdown directory was never generated from a catalog — assemble cannot invent the catalog metadata it needs. - Don't use when: You want a profile json out of profile markdown; use trestle_author_profile_assemble.

Inputs: params (required). Returns: result

trestle_author_catalog_generateGenerate Catalog Markdown ControlsA
Destructive

Generate Catalog controls in markdown form from a catalog in the trestle workspace.

Args: params (TrestleCatalogGenerateInput): Input parameters with: - name (str): Catalog model name (required) - output (str): Output markdown folder (required) - force_overwrite (bool): Force overwrite markdowns (optional) - yaml_header (Optional[str]): Path to yaml header file (optional) - overwrite_header_values (bool): Overwrite markdown header values (optional) - trestle_root (Optional[str]): Trestle workspace root path (optional) - verbose (bool): Display verbose output (optional)

Returns: str: Success or error message

Examples: - Use when: "Generate markdown controls from a catalog" - Use when: "Split a catalog JSON into control-wise markdowns" - Don't use when: "Catalog is missing or output directory already exists and not overwritten"

Inputs: params (required). Returns: result

trestle_author_component_assembleAssemble Component Definition from MarkdownA
Destructive

Assemble markdown files of controls into a component-definition json file.

This is the return leg of the component authoring round trip: generate markdown with trestle_author_component_generate, edit the implementation prose and the rule/parameter yaml headers, then assemble back into component-definitions//component-definition.json.

Unlike catalog-assemble and profile-assemble there is no set-parameters flag — component markdown headers (rules, parameter values, implementation status) are always read back.

Pass name whenever output is a name that does not already exist. The source model defaults to the output name, so assembling into a new component-definition without name fails with "Unable to load model without specifying json or yaml". (catalog-assemble does not have this constraint — it takes the source from the markdown header.)

Args: params (TrestleAuthorComponentAssembleInput): Input parameters with: - markdown (str): Source markdown directory (required) - output (str): Output json component-definition name (required) - name (Optional[str]): Source component-definition model name (defaults to output) - regenerate (bool): Force generation of new uuids (default: false) - version (Optional[str]): New version for the assembled model - trestle_root (Optional[str]): Trestle workspace root path - verbose (bool): Display verbose output

Returns: str: Success or error message

Examples: - Use when: "Write the implementation prose I edited back into the component definition" - Use when: "Assemble the component definition and bump its version" - Don't use when: The markdown directory was not produced by component-generate.

Inputs: params (required). Returns: result

trestle_author_component_generateGenerate Component MarkdownA
Destructive

Generate component in markdown form from a component-definition in the trestle workspace.

This writes one markdown file per control implementation, per component, under ///. The markdown is where an author writes the implementation prose and the rule/parameter yaml header that trestle_author_component_assemble reads back.

Note that generate only writes what the component-definition already declares: it will not create implemented requirements for controls the component-definition does not claim.

Args: params (TrestleAuthorComponentGenerateInput): Input parameters with: - name (str): Source component-definition model name (required) - output (str): Output markdown folder (required) - force_overwrite (bool): Overwrite existing markdown content, discarding edits (default: false) - trestle_root (Optional[str]): Trestle workspace root path - verbose (bool): Display verbose output

Returns: str: Success or error message

Examples: - Use when: "Generate editable markdown for this component definition" - Use when: "Let me write implementation prose for each control a component claims" - Don't use when: There is no component-definition in the workspace yet; import one, or create one with trestle_task_csv_to_oscal_cd. - Don't use when: You only want to regenerate without losing edits — force_overwrite discards author prose.

Inputs: params (required). Returns: result

trestle_author_profile_assembleAssemble Profile JSON from Markdown DirectoryA
Destructive

Assemble markdown controls into a Profile JSON file.

This tool assembles an OSCAL profile JSON (profile.json) from a directory of markdown controls for a profile.

Args: params (TrestleAuthorProfileAssembleInput): - markdown_dir (str): Markdown controls directory (required) - output_profile (str): Output profile directory name (required) - name (Optional[str]): Profile model name - set_parameters (bool): Expand parameters from YAML frontmatter - regenerate (bool): Force UUID regeneration - version (Optional[str]): Model version - sections (Optional[str]): Section info (short:long, comma-separated) - required_sections (Optional[str]): Required section short names, comma-separated - allowed_sections (Optional[str]): Allowed section short names, comma-separated - verbose (bool): Verbose output - trestle_root (Optional[str]): Path of trestle root directory

Returns: str: Success message with stdout, or error message with stderr details

Examples: - Use when: Automatically assemble OSCAL profile from markdown directory - Use when: CI/CD profile assembling, parameter expansion - Don't use when: Input markdown_dir does not exist, or malformed markdown

Inputs: params (required). Returns: result

trestle_author_profile_generateGenerate Profile Markdown ControlsB
Destructive

Generate markdown documentation set for controls defined in specified profile.

This tool extracts controls defined in the specified profile (profiles//profile.json) and generates a set of markdown documents for them. This set can be used for custom documentation, reviews, and organization-specific profile documentation.

Args: params (TrestleAuthorProfileGenerateInput): - name (str): profile name (required) - output (str): output directory for markdown docs (required) - yaml_header (Optional[str]): yaml header file path - force_overwrite (bool): overwrite all in output dir - overwrite_header_values (bool): overwrite header values only - sections (Optional[str]): targeted sections in markdown - required_sections (Optional[str]): required section short names, comma-separated - trestle_root (Optional[str]): workspace root path - verbose (bool): verbose output

Returns: str: Success message or error details

Examples: - Use when: "Generate markdown controls for a given profile" - Use when: "Customize output with required sections or header overwrite" - Don't use when: Profile file does not exist

Inputs: params (required). Returns: result

trestle_author_profile_resolveResolve Profile to CatalogA
Destructive

Resolve an OSCAL profile to a resolved profile catalog.

This tool resolves a specified OSCAL profile (by name from profiles//profile.json) into an operational, parameter-resolved OSCAL catalog, with flexible output and formatting options.

Args: params (TrestleAuthorProfileResolveInput): - name (str): Source profile name (required) - output (str): Output catalog name (required) - show_values (bool): Show parameter values in prose (optional) - show_labels (bool): Show parameter labels in prose (optional) - bracket_format (str): Bracket format for values (optional) - value_assigned_prefix (str): Prefix if value is assigned (optional) - value_not_assigned_prefix (str): Prefix if value not assigned (optional) - label_prefix (str): Prefix for label output (optional) - verbose (bool): Display verbose output (optional) - trestle_root (str): Path to trestle root directory (optional)

Returns: str: Result summary string. On success, a checked message with output. On failure, a cross mark and error details.

Examples: - Minimal invocation trestle_author_profile_resolve(name="myprofile", output="catalog_resolved") - With options trestle_author_profile_resolve(name="myprofile", output="catalog_resolved", show_values=True, bracket_format="(.)")

Inputs: params (required). Returns: result

trestle_importImport OSCAL ModelA

Import an existing OSCAL model into the trestle workspace.

This tool imports OSCAL models from URLs or local file paths. The imported file will be saved in the appropriate directory based on its OSCAL type (e.g., catalogs/, profiles/, component-definitions/).

Import Behavior:

  • Catalog → catalogs/{output}/catalog.json

  • Profile → profiles/{output}/profile.json

  • Component Definition → component-definitions/{output}/component-definition.json

  • SSP → system-security-plans/{output}/system-security-plan.json

Args: params (TrestleImportInput): Validated input parameters containing: - file (str): OSCAL file to import (URL or file path) - output (str): Name of output element - regenerate (bool): Force generation of new UUIDs (default: false) - trestle_root (Optional[str]): Path to trestle root directory - verbose (bool): Display verbose output (default: false)

Returns: str: Success message with import details or error

Examples: - Import NIST SP800-53 Rev5 Catalog: file="https://raw.githubusercontent.com/usnistgov/oscal-content/refs/heads/main/nist.gov/SP800-53/rev5/json/NIST_SP-800-53_rev5_catalog.json" output="nist_sp800_53_rev5"

- Import from local file:
  file="./resources/catalogs/your_catalog.json"
  output="mycatalog"

Inputs: params (required). Returns: result

trestle_initInitialize Trestle WorkspaceA
Destructive

Initialize a trestle working directory.

This tool initializes the current directory as a Trestle workspace, creating the necessary directory structure for OSCAL model management.

Do not run this on a workspace that is already initialized. Creating the directories is harmless -- they are only made when missing -- but local and full mode also copy trestle's stock .trestle/config.ini over whatever is there, with no check and no warning, and still report success. That file is where trestle task reads its [task.*] sections from, so an operator's task configuration is gone. Check for a .trestle directory before calling this; there is nothing to gain by running it again.

OSCAL Model Types supported:

  • Catalog

  • Profile

  • Component Definition

  • System Security Plan (SSP)

  • Assessment Plan

  • Assessment Result

  • Plan of Action and Milestones (POAM)

Args: params (TrestleInitInput): Validated input parameters containing: - mode (InitMode): Initialization mode (local/full/govdocs, default: local) - trestle_root (Optional[str]): Path to trestle root directory - verbose (bool): Display verbose output (default: false)

Returns: str: Success message or error details

Examples: - Use when: "Initialize trestle workspace" - Use when: "Set up trestle in full mode" - Don't use when: Workspace is already initialized — this overwrites .trestle/config.ini rather than leaving it alone.

Inputs: params (required). Returns: result

trestle_task_csv_to_oscal_cdConvert CSV to OSCAL Component DefinitionB
Destructive

Convert a CSV file to an OSCAL component definition JSON file.

This tool runs the trestle task csv-to-oscal-cd command, which reads a specially formatted CSV file and produces an OSCAL component_definition .json file.

The CSV must have:

  • Row 1: column headings

  • Row 2: column descriptions

  • Row 3+: data rows

Required CSV columns:

  • $$Component_Title, $$Component_Description, $$Component_Type

  • $$Rule_Id, $$Rule_Description, $$Profile_Source, $$Profile_Description

  • $$Control_Id_List, $$Namespace

Args: params (TrestleTaskCsvToOscalCdInput): Input parameters with: - title (str): Component definition title (required) - version (str): Component definition version (required) - csv_file (str): Path to the input CSV file (required) - output_dir (str): Output directory for OSCAL JSON files (required) - component_definition (Optional[str]): Existing component-definition to update (optional) - output_overwrite (bool): Overwrite existing output (default: true) - validate_controls (str): Control validation mode: on/warn/off (default: off) - class_column_mappings (Optional[dict]): Column-to-class mappings (optional) - trestle_root (Optional[str]): Trestle workspace root path (optional) - verbose (bool): Display verbose output (optional)

Returns: str: Success or error message with output file location

Examples: - Use when: "Convert CSV to OSCAL component definition" - Use when: "Generate component_definition.json from a CSV mapping file" - Don't use when: Input CSV is missing required columns

Inputs: params (required). Returns: result

trestle_task_csv_to_oscal_mcConvert CSV to OSCAL Mapping CollectionA
Destructive

Convert a CSV file to an OSCAL mapping-collection JSON file.

This tool runs the trestle task csv-to-oscal-mc command, which reads a specially formatted CSV of control-to-control correspondences and produces mapping-collection.json — the OSCAL model for "control X over here means the same thing as controls Y and Z over there".

The CSV must have:

  • Row 1: column headings

  • Row 2: column descriptions

  • Row 3+: data rows

Required CSV columns:

  • $$Source_Resource, $$Target_Resource: for each side, a path to a catalog JSON file or an href to a profile. Both sides are loaded and every id in the ref lists is looked up in them. An id that is not found is dropped without a warning, and the row is still written with whatever ids did resolve: ac-1 ac-99-typo on one side produces a map naming ac-1 only, and the run reports success. It fails only when nothing in a row's list resolves at all. So a successful run does not mean every id in the CSV made it into the output -- check the id-refs in mapping-collection.json against the CSV if the mapping has to be complete.

  • $$Map_Source_Id_Ref_List, $$Map_Target_Id_Ref_List: whitespace-separated control ids, or statement ids such as ac-1_smt.a. Several ids on one side are what makes a mapping many-to-many.

  • $$Map_Relationship: the relationship type, as an NCName token. The conventional values are the NIST IR 8477 section 4.3 set-theory relationships — equivalent, subset-of, superset-of, intersects-with, no-relationship — but trestle does not restrict the vocabulary. Leave the cell empty to declare a control unmapped: it is then recorded in the gap summary instead of producing a map entry.

Optional CSV columns:

  • $$Map_Confidence_Score, $$Map_Coverage: percentages expressed in the range 0 to 1, not 0 to 100. A value of 80 is silently dropped with a "Percentage value out of range" warning and the map entry is written without it; write 0.8.

Resource paths in the CSV are resolved relative to the trestle process's working directory, which is trestle_root when you pass one and wherever the server was started when you do not. Pass trestle_root, or use absolute paths, so the CSV does not depend on how the server was launched.

Args: params (TrestleTaskCsvToOscalMcInput): Input parameters with: - title (str): Mapping collection title (required) - version (str): Mapping collection version (required) - csv_file (str): Path to the input CSV file (required) - output_dir (str): Output directory for mapping-collection.json (required) - output_overwrite (bool): Overwrite existing output (default: true) - trestle_root (Optional[str]): Trestle workspace root path (optional) - verbose (bool): Display verbose output (optional)

Returns: str: Success or error message with the output file location

Examples: - Use when: "Map our internal control set onto NIST SP 800-53" - Use when: "Produce an OSCAL mapping collection from this crosswalk spreadsheet" - Don't use when: You want a component definition out of a CSV; use trestle_task_csv_to_oscal_cd. - Don't use when: The CSV is missing a required column, or names control ids that are not in the source or target resource.

Inputs: params (required). Returns: result

trestle_task_xlsx_to_oscal_poamConvert FedRAMP XLSX to OSCAL POA&MA
Destructive

Convert a FedRAMP XLSX spreadsheet to an OSCAL POA&M JSON file.

This tool runs the trestle task xlsx-to-oscal-poam command, which reads a FedRAMP-format .xlsx spreadsheet and produces an OSCAL plan-of-action-and-milestones .json file. The converter auto-generates the observations[] and risks[] and cross-links each poam-item to them with deterministic UUIDs.

This command must run inside a trestle workspace: initialize one first with trestle_init and pass its path as trestle_root (or run from within it).

The spreadsheet must have:

  • Row 1: title

  • Rows 2-4: instructions (ignored)

  • Row 5: column headers

  • Row 6+: data rows

Required columns:

  • POAM ID, Weakness Name, Weakness Description, Controls

Args: params (TrestleTaskXlsxToOscalPoamInput): Input parameters with: - title (str): POA&M title (required) - version (str): POA&M version (required) - xlsx_file (str): Path to the input .xlsx file (required) - output_dir (str): Output directory for the OSCAL JSON (required) - work_sheet_name (Optional[str]): Worksheet name (default: 'Open POA&M Items') - system_id (Optional[str]): System identifier (optional) - output_overwrite (bool): Overwrite existing output (default: true) - validate_required_fields (str): Required-field check: on/warn/off (default: warn) - quiet (bool): Suppress per-item output (default: false) - trestle_root (Optional[str]): Trestle workspace root path (optional) - verbose (bool): Display verbose output (optional)

Returns: str: Success or error message with output file location

Examples: - Use when: "Convert this FedRAMP POA&M spreadsheet to OSCAL" - Use when: "Generate plan-of-action-and-milestones.json from an xlsx" - Don't use when: The input is a CSV, or is missing required columns

Inputs: params (required). Returns: result

trestle_validateValidate OSCAL DocumentA
Read-onlyIdempotent

Validate a standalone OSCAL file against the OSCAL schema.

This tool loads the OSCAL document through the trestle model classes, which enforces the OSCAL schema (required fields, field types, enums, UUID formats, and nesting). Optionally it also runs trestle's semantic validators (duplicate UUIDs, broken internal references, links, and rule parameters).

It detects the model type from the file's single top-level wrapper key, so it validates any top-level OSCAL model: catalog, profile, component-definition, system-security-plan, assessment-plan, assessment-results, mapping-collection, or plan-of-action-and-milestones -- the same list as model_type elsewhere in this server.

Unlike trestle validate on the CLI, this works on a standalone file that is not part of a trestle workspace — for example a POA&M JSON produced by an authoring flow.

Args: params (TrestleValidateInput): Input parameters with: - file (str): Path to the OSCAL .json/.yaml/.yml file (required) - expected_model_type (Optional[str]): Enforce the file is this model type (e.g. 'plan-of-action-and-milestones') - semantic (bool): Run semantic validators too (default: true)

Returns: str: A pass/fail message; on failure, the concrete reasons.

Examples: - Use when: "Validate this POA&M JSON is valid OSCAL" file="./poam.json", expected_model_type="plan-of-action-and-milestones" - Use when: "Check that catalog.json conforms to the OSCAL schema" - Don't use when: The file is inside a trestle workspace and you want the full trestle validate workspace checks.

Inputs: params (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 13 tools

    Disambiguation5/5

    Each tool targets a distinct model+action combination: the catalog/profile/component generate-vs-assemble pairs are explicitly framed as round-trip halves, and the task converters are separated by input format and output model. trestle_validate and trestle_import have clear roles, and profile_resolve is uniquely a profile-to-catalog operation.

    Naming Consistency4/5

    All names are snake_case with a coherent trestle_ prefix and a consistent verb_noun shape within three clear sub-namespaces (trestle_<verb>, trestle_author_<model>_<verb>, trestle_task_<format>_to_oscal_<model>). The only minor deviation is profile_resolve sitting among the authoring verbs, but it remains readable and predictable.

    Tool Count5/5

    Thirteen tools is squarely in the well-scoped range and each earns its place: one init/import/validate plus paired authoring tools for three model types plus three format converters. There is no filler or duplicate tool.

    Completeness4/5

    The surface covers the core lifecycle: workspace init, import, validate, full generate/assemble round-trips for catalog, profile, and component-definition, and CSV/XLSX conversion tasks. Gaps remain — no listing/inventory of workspace models, no explicit export, and SSP/assessment/POA&M authoring only via import or conversion — but these are workaroundable.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers