Cyber Framework Skills Maintainer
chris-aaro/Cyber-Framework-Skills-Maintainer
Manutenção automática de Skills Claude para frameworks de segurança
Ver no GitHubSistema automatizado para manter Claude Skills precisos e atualizados sobre frameworks de cibersegurança, monitorando fontes oficiais (como NIST) e detectando mudanças. Usa rotinas semanais de Claude Code para atualizar conteúdo de referência, gerar changelogs e abrir pull requests para revisão humana.
Instalação
npx convez-ai chris-aaro/Cyber-Framework-Skills-Maintainer1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Manter Skills especializadas em frameworks NIST atualizadas automaticamente
- Monitorar mudanças em padrões de cibersegurança e AI risk management
- Validar conformidade de conteúdo técnico com fontes oficiais
Veredito

Projeto maduro e bem-estruturado para manter Skills técnicas sincronizadas com padrões públicos. Excelente referência de automação CI/CD em GitHub para conteúdo de referência, mas requer experiência com Python, GitHub Actions e frameworks NIST para operacionalizar.
README
A tradução para o português deste README ainda está na fila.
Cyber Framework Claude Skills Maintainer
A system for keeping Claude Skills accurate and current for cybersecurity and AI risk frameworks. Each skill turns Claude into a reliable expert on a specific framework based the latest version.
A weekly Claude Code routine does the intelligent maintenance work: it detects when a framework's official source has changed, updates the bundled reference content, authors the changelog, and opens a pull request for human review. GitHub hosts the repo and runs a CI validation gate; it never touches the skill content itself.
Frameworks are registered in frameworks.yaml. The three
initial frameworks are:
| Framework | Skill | Version (pinned) | Bundled content |
|---|---|---|---|
| NIST SP 800-53 | skills/nist-sp-800-53 | 5.2.0 | structured (OSCAL) |
| NIST Cybersecurity Framework 2.0 | skills/nist-csf-2.0 | 2.0 | reference-only* |
| NIST AI Risk Management Framework 1.0 | skills/nist-ai-rmf-1.0 | 1.0 | reference-only* |
* CSF 2.0 and AI RMF currently reference official sources by URL; bundling their full structured content is a follow-up (see Bundled content).
Scope: this system targets public-domain frameworks (e.g. NIST). Embedding full official text is only done because NIST works are public domain — do not add copyrighted standards (ISO, PCI DSS, CIS, SOC 2) as bundled content.
New frameworks can be added by following Adding a new framework.
Design philosophy: source fidelity
Every skill enforces two rules:
- Never invent framework requirements, control/subcategory IDs, mappings, or
official language. Official text comes from the bundled structured reference
files (
references/) or cited sources insources.yaml— never reconstructed from memory. - Always distinguish official framework text (
[OFFICIAL]) from[INTERPRETATION],[IMPLEMENTATION]advice, and[MAPPING RATIONALE].
The validator enforces structure and flags over-claiming language such as "NIST mandates" or "guarantees compliance".
How it works
Keeping a skill current requires two kinds of work: cheap, deterministic checking and intelligent authoring. They live in different places on purpose.
The weekly Claude Code routine is the primary maintenance path. It runs
routines/weekly-maintenance.md on a schedule:
- Runs the monitor to detect version drift against live official sources.
- Regenerates the bundled reference content from the official machine-readable artifact.
- Reviews what changed, authors the changelog summary, and updates
SKILL.mdstructure if needed. - Validates everything and opens a pull request per framework for human review.
GitHub provides the hosting and review infrastructure:
validate.yml— CI gate that runs on every push/PR; blocks merges if validation fails.monitor.yml— weekly check for non-version changes (unreachable sources, metadata shifts); opens issues for human triage.propose-update.yml— manual-only fallback that bumps a version number if the routine is unavailable.- Branch protection ensures nothing reaches
mainwithout a passing CI check and human approval.
Repository layout
frameworks.yaml # registry of all frameworks (single source of truth)
requirements.txt # PyYAML + pytest (everything else is stdlib)
pytest.ini
common/utils.py # shared helpers: YAML/JSON IO, http_get, hashing
monitors/monitor.py # fetch sources, classify changes, open issues
monitors/propose_update.py # deterministic version-bump PR (manual fallback)
references/ingest.py # download + transform official structured content
references/transforms.py # per-format transforms (e.g. OSCAL -> split files)
validation/validate_skills.py# structure + guardrail + reference validation (CI gate)
routines/weekly-maintenance.md # playbook the weekly Claude Code routine runs
skills/<framework>/
SKILL.md # the Claude Skill (guardrails + workflows)
framework_profile.yaml # id/version/structure/content_mode (must match registry)
sources.yaml # canonical + related + structured_content sources
source_state.json # last-observed snapshot per source (no DB)
changelog.md # Keep-a-Changelog history
references/ # bundled structured content (structured skills only)
index.json # self-describing manifest (version + family files)
controls/<family>.json # split, diffable content for progressive disclosure
tests/test_skill.py # per-skill validation tests
.github/workflows/
monitor.yml # scheduled monitoring -> GitHub issues
validate.yml # push/PR -> validate skills + tests
propose-update.yml # manual deterministic version-bump fallback
No database is required. The only dependency beyond Python stdlib is PyYAML.
Bundled reference content
Skills with content_mode: structured bundle the framework's full content as
split, diffable JSON under references/, so Claude cites real official text
instead of recalling it from memory. SKILL.md stays thin and points at the data
(progressive disclosure: read index.json, then load only the family file you
need).
The content is produced deterministically by references/ingest.py from official
machine-readable artifacts (800-53 uses the public-domain OSCAL catalog from
usnistgov/oscal-content). Regenerate / verify:
python references/ingest.py --framework nist-sp-800-53 # download + transform + write
python references/ingest.py --check # report if on-disk content is stale
The reference index.json version must equal the registry version — the validator
enforces this, so a version bump and a content refresh always travel together.
CSF 2.0 and AI RMF are not yet bundled (no clean public JSON identified; NIST's CPRT export is xlsx, which we avoid to keep dependencies to PyYAML only). They remain reference-only until a structured source + transform is added.
Setup
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
Setting up the weekly routine
Create a scheduled Claude Code routine pointing at
routines/weekly-maintenance.md. The routine's
environment needs git and gh authenticated with permission to push branches and
open PRs on this repo (not main write).
Usage
Validate skills
python validation/validate_skills.py # human-readable, exits non-zero on failure
python validation/validate_skills.py --json # machine-readable
python validation/validate_skills.py --framework nist-csf-2.0
python -m pytest -q # per-skill + transform tests
The validator checks that each skill has all required files, that SKILL.md
has all required sections, that framework_profile.yaml matches the registry
id and version, that changelog.md is non-empty, that sources.yaml has at
least one canonical source, and that no risky/over-claiming language appears in
SKILL.md unless tagged [JUSTIFIED: ...] or shown inside a
risky-language-reference example block. For content_mode: structured skills it
also confirms the ## Reference Data section, that the reference index exists, and
that its version matches the registry and its listed family files are present.
Monitor sources
# Safe local dry run (classifies only, never opens issues, never writes state):
python monitors/monitor.py --dry-run
# Establish/update local baseline state after a reviewed change:
python monitors/monitor.py --write --framework nist-ai-rmf-1.0
How change monitoring works
For each source in a skill's sources.yaml, the monitor records reachability,
HTTP status, a SHA-256 of the page/file, the page title, and any detected
version / publication date (via expected_metadata regex hints). It compares
the new observation to source_state.json and classifies the change as exactly
one of:
| Classification | Action | Meaning |
|---|---|---|
no_change | none | All tracked signals identical (or first-run baseline). |
cosmetic_page_change | none | Body hash changed but title/version/date stable. |
source_unreachable | issue | Fetch failed or non-2xx response. |
metadata_change | issue | Title/date changed, version unchanged. |
related_resource_change | issue | Change on a related (non-canonical) source. |
ambiguous_requires_review | issue | Change detected but not confidently classified. |
errata_or_patch | routine | Patch-level version bump or "errata" detected. |
new_framework_version | routine | Major/minor version increase. |
Version drift (the bottom two rows) is detected by the monitor but handled by the weekly routine, which fetches the new content, updates the bundled references, and opens a full content PR. Everything else has no automated fix, so the monitor opens a GitHub issue for a human to triage.
Maintenance flows
A. Version drift → Claude Code routine opens a content PR (primary)
The weekly routine (routines/weekly-maintenance.md)
detects that a framework's pinned version is behind its live source, then:
- bumps
versioninframeworks.yaml+framework_profile.yaml; - regenerates the bundled
references/viareferences/ingest.py; - drafts the
changelog.mdsummary and anySKILL.md/structure updates, grounded in the official change list and the reference diff; - runs validation, opens one PR per framework.
You review and approve.
B. Non-version changes → GitHub issue (monitor.yml)
The monitor opens an issue (deduplicated by title) for changes with no
automated fix: source_unreachable, metadata_change, related_resource_change,
ambiguous_requires_review. A human triages.
C. Deterministic version-bump → manual fallback (propose-update.yml)
If the routine is unavailable, trigger propose-update.yml by hand. It opens a PR
that bumps only the version number (no content update) — a stopgap, not the
primary path.
In all cases validation must pass and nothing is auto-pushed to main.
Adding a new framework
- Add an entry to
frameworks.yamlwith:id,name,version,skill_dir,profile,sources, andstatepaths. - Create
skills/<id>/with the six required members. Copy an existing skill folder as a starting point:cp -r skills/nist-csf-2.0 skills/<new-framework-id> - Edit all six files for the new framework:
SKILL.md— update Purpose, Scope, and Framework-Specific Workflows.framework_profile.yaml— setframework_id,version,publisher,official_structure.sources.yaml— add at least one canonical source withexpected_metadatahints.source_state.json— seed all source entries withnullvalues.changelog.md— add an initial entry.tests/test_skill.py— update theFRAMEWORK_IDconstant and any framework-specific assertions.
- (Optional, recommended) bundle full content: add a
structured_contentsource tosources.yamlwith atransformregistered inreferences/transforms.py, setcontent_mode: structured+reference_index: references/index.jsonin the profile, add a## Reference Datasection toSKILL.md, then runpython references/ingest.py --framework <id>. - Run the full validation suite:
python validation/validate_skills.py python -m pytest -q
Notes & limitations
- Version/date detection uses conservative regex heuristics; when uncertain the
monitor prefers
ambiguous_requires_reviewover guessing. - The pinned
version/publication_datein eachframework_profile.yamlshould be verified against the canonical source before being relied upon.