convez.ai
SkillSegurançaAvançado
chris-aaro

Cyber Framework Skills Maintainer

chris-aaro/Cyber-Framework-Skills-Maintainer

Manutenção automática de Skills Claude para frameworks de segurança

Ver no GitHub
InicialPluginScore · de 0 a 100

Sistema 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-Maintainer

1 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

Estrelas
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

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:

FrameworkSkillVersion (pinned)Bundled content
NIST SP 800-53skills/nist-sp-800-535.2.0structured (OSCAL)
NIST Cybersecurity Framework 2.0skills/nist-csf-2.02.0reference-only*
NIST AI Risk Management Framework 1.0skills/nist-ai-rmf-1.01.0reference-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:

  1. Never invent framework requirements, control/subcategory IDs, mappings, or official language. Official text comes from the bundled structured reference files (references/) or cited sources in sources.yaml — never reconstructed from memory.
  2. 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:

  1. Runs the monitor to detect version drift against live official sources.
  2. Regenerates the bundled reference content from the official machine-readable artifact.
  3. Reviews what changed, authors the changelog summary, and updates SKILL.md structure if needed.
  4. 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 main without 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:

ClassificationActionMeaning
no_changenoneAll tracked signals identical (or first-run baseline).
cosmetic_page_changenoneBody hash changed but title/version/date stable.
source_unreachableissueFetch failed or non-2xx response.
metadata_changeissueTitle/date changed, version unchanged.
related_resource_changeissueChange on a related (non-canonical) source.
ambiguous_requires_reviewissueChange detected but not confidently classified.
errata_or_patchroutinePatch-level version bump or "errata" detected.
new_framework_versionroutineMajor/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:

  1. bumps version in frameworks.yaml + framework_profile.yaml;
  2. regenerates the bundled references/ via references/ingest.py;
  3. drafts the changelog.md summary and any SKILL.md/structure updates, grounded in the official change list and the reference diff;
  4. 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

  1. Add an entry to frameworks.yaml with: id, name, version, skill_dir, profile, sources, and state paths.
  2. 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>
    
  3. Edit all six files for the new framework:
    • SKILL.md — update Purpose, Scope, and Framework-Specific Workflows.
    • framework_profile.yaml — set framework_id, version, publisher, official_structure.
    • sources.yaml — add at least one canonical source with expected_metadata hints.
    • source_state.json — seed all source entries with null values.
    • changelog.md — add an initial entry.
    • tests/test_skill.py — update the FRAMEWORK_ID constant and any framework-specific assertions.
  4. (Optional, recommended) bundle full content: add a structured_content source to sources.yaml with a transform registered in references/transforms.py, set content_mode: structured + reference_index: references/index.json in the profile, add a ## Reference Data section to SKILL.md, then run python references/ingest.py --framework <id>.
  5. 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_review over guessing.
  • The pinned version / publication_date in each framework_profile.yaml should be verified against the canonical source before being relied upon.
Ver o original no GitHub

Bom para

Relacionados