Claude Code with Opus is recommended for quality; any capable model works.

📑 Table of contents

• ✨ Highlights
• 🔄 Flow
• 🔍 What it detects
• 📦 Installation
• 🚀 Running a scan
• 🔌 CI integrations
• 🩺 Verify & troubleshoot
• 🤝 Contributing
• 📄 License

✨ Highlights

• 68 skills across 64 vulnerability classes — injection (incl. XPath, expression-language, CSV-formula, XML-bomb variants), broken access control, API & session depth (rate-limiting, OAuth/OIDC, session fixation, shadow routes), weak crypto, file handling, supply chain, CI/CD & cloud-metadata risks, business logic & payment abuse, agentic/MCP security (skill-config poisoning, MCP tool poisoning, config-as-execution, over-privileged agent identity), and LLM/agent runtime (excessive agency, RAG isolation, unsafe tool calling, memory poisoning, denial-of-wallet), plus a tech-stack router.
• Four-phase orchestration — reconnaissance → parallel detection → consolidated report → evidence-based triage, driven entirely from CLAUDE.md / AGENTS.md.
• Idempotent & resumable — each phase skips work whose output already exists; re-run after fixing issues to refresh only what's stale.
• Machine-readable output — every skill emits canonical JSON; sast-skills export aggregates to JSON, SARIF 2.1.0, or HTML for GitHub Code Scanning and CI.
• Cross-assistant — identical skills ship for Claude Code (.claude/skills) and every AGENTS.md assistant (.agents/skills).
• Zero-config CLI — install / update / uninstall / doctor / export, published from GitHub Actions with npm provenance (SLSA attestation).

🔄 Flow

The orchestrator executes four phases — reconnaissance, parallel detection, synthesis, and triage:

flowchart TD
    U(["User: Run vulnerability scan"]) --> R{"CLAUDE.md / AGENTS.md orchestrator"}
    R --> S1["Step 1 — sast-analysis<br/>codebase and architecture map"]
    S1 -->|sast/architecture.md| S2["Step 2 — parallel vulnerability scan<br/>64 skills: recon, batched verify, merge"]
    S2 -->|sast/*-results.md and *-results.json| S3["Step 3 — sast-report<br/>consolidate and rank"]
    S3 -->|sast/final-report.md| S4["Step 4 — sast-triage<br/>false-positive elimination,<br/>severity adjustment with evidence"]
    S4 -->|sast/final-report-triaged.md and triaged.json| EXP["npx sast-skills export<br/>JSON, SARIF, HTML"]
    EXP --> CS(["GitHub Code Scanning, CI, dashboards"])

Every step is idempotent: if its output file already exists, the orchestrator skips it. Re-run the scan after fixing issues to refresh only what's stale.

🔍 What it detects

All skills follow the same three-phase pattern: recon → batched verify (parallel subagents, 3 per batch) → merge. Each writes a human-readable markdown report and a canonical JSON findings file that sast-skills export aggregates.

Reconnaissance & Synthesis

Injection

Access control & Auth

Files, crypto & runtime

Data exposure & supply chain

Business logic & LLM-specific

Agentic & MCP security

The 2026-era attack surface most signature scanners miss — natural-language manipulation, MCP tool poisoning, config-as-execution, and over-privileged agent identities. These skills use an LLM-driven verify step, not regex matching.

LLM & agent runtime

Runtime behaviour of LLM and agent applications — tool authority, retrieval isolation, prompt-secret hygiene, memory trust, and cost bounds. The tech-stack router gates these so they never run on codebases with no LLM/agent dependencies.

🔌 CI integrations

GitHub Code Scanning (SARIF)

Composite action at .github/actions/scan/action.yml:

- uses: mstfknn/sast-skills/.github/actions/scan@main
  with:
    input: sast/
    output: sast-skills.sarif

This runs sast-skills export --format sarif and uploads the result to Code Scanning via github/codeql-action/upload-sarif@v3.

Pre-commit hook

Copy hooks/pre-commit into .git/hooks/pre-commit to make sast-skills doctor gate every commit.

Docker

docker build -t sast-skills .
docker run --rm -v "$PWD:/work" sast-skills export --input sast/ --format sarif --output report.sarif

The bundled Dockerfile is node:20-alpine-based with sast-skills set as the entrypoint.

🤝 Contributing

See CONTRIBUTING.md. Developer loop:

npm install
npm test                                  # vitest suite (TDD-guard enabled; count shown in the tests badge)
npm run sync                              # mirror .claude/skills → .agents/skills
node scripts/scaffold-skill.js sast-foo   # stub a new skill in both trees
node scripts/register-skill.js sast-foo foo "Foo" "Foo injection description"
npm run lint:md                           # markdownlint

prepublishOnly runs npm run sync && npm test — a dirty mirror or a red test aborts npm publish.

• Community standards: CODE_OF_CONDUCT.md
• Release history: CHANGELOG.md

📄 License

MIT — see LICENSE.

⚡ Quick start

npx sast-skills install   # pick your assistant(s) — ones found on your PATH are pre-enabled

Then open the project in your assistant and prompt:

Run vulnerability scan

It runs all four phases and writes findings to sast/. Aggregate them with npx sast-skills export --format sarif for GitHub Code Scanning or CI.

📦 Installation

npx sast-skills install

The installer shows a multi-select of all 14 supported assistants (plus All of the above) and asks whether to install into the current project or your user home directory (project / global). To skip prompts, pass a comma-separated list of assistant ids (or all):

npx sast-skills install --yes --assistant claude,cursor,copilot --scope project

If your project already contains a CLAUDE.md or AGENTS.md, the installer refuses to clobber it by default — back it up or pass --force.

git clone https://github.com/mstfknn/sast-skills.git

sast-files/
├── CLAUDE.md                       # Orchestrator entry for Claude Code
├── AGENTS.md                       # Orchestrator entry for Gemini CLI / Codex / OpenCode / Cursor
├── .claude/skills/sast-*/SKILL.md  # 68 skills in Claude Code format
└── .agents/skills/sast-*/SKILL.md  # Same 68 skills mirrored for AGENTS.md assistants

export SAST_SRC=/absolute/path/to/sast-skills
cd /path/to/your-project

cp "$SAST_SRC/sast-files/CLAUDE.md" ./CLAUDE.md
cp -R "$SAST_SRC/sast-files/.claude" ./

mkdir -p ~/.claude/skills
cp -R "$SAST_SRC/sast-files/.claude/skills/." ~/.claude/skills/
# Then in any project where you want the scan flow:
cp "$SAST_SRC/sast-files/CLAUDE.md" /path/to/your-project/CLAUDE.md

export SAST_SRC=/absolute/path/to/sast-skills
cd /path/to/your-project
cp "$SAST_SRC/sast-files/AGENTS.md" ./AGENTS.md
cp -R "$SAST_SRC/sast-files/.agents" ./

# Project scope (Claude Code)
ls CLAUDE.md && ls .claude/skills/ | head

# Project scope (Gemini / AGENTS.md)
ls AGENTS.md && ls .agents/skills/ | head

# Global scope (Claude Code)
ls ~/.claude/skills/ | head

cd "$SAST_SRC" && git pull
# Re-run the cp commands from Step 2a / 2b to refresh — they're idempotent.

CLI commands

Install-time flags

🚀 Running a scan

After installing, open the project in your AI assistant and ask:

Run vulnerability scan

or

Find vulnerabilities in this codebase

The orchestrator takes over. It runs all four phases automatically, respects idempotency (re-runs only pick up what's missing), and writes everything into sast/ in your project root.

Output files

Finding schema

Each skill writes sast/<skill>-results.json as a bare findings list:

{
  "findings": [
    {
      "id": "sast-sqli-0001",
      "skill": "sast-sqli",
      "severity": "critical|high|medium|low|info",
      "title": "SQL injection in /api/user",
      "description": "…",
      "location": { "file": "src/api/user.js", "line": 42, "column": 10 },
      "remediation": "…"
    }
  ]
}

sast-skills export aggregates those files into one document wrapped in a run envelope — { "run": { "tool": "sast-skills", "version": "<cli-version>" }, "findings": [...] } — stamping the version of the CLI that produced the report. The triage step writes sast/triaged.json in that same enveloped shape.

Triaged findings add triage_status (confirmed|upgraded|downgraded|false_positive), triage_original_severity (when severity changed), and triage_evidence with concrete codebase citations.

🩺 Verify & troubleshoot

# Is the install in the expected shape?
npx sast-skills doctor --target . --assistant claude

# Version check
npx sast-skills --version
npm view sast-skills version    # latest on the registry

# Upgrade
npx sast-skills update

doctor exits 0 if every bundled file in the target matches the installed version's copy, and 1 if any file is MISSING or MODIFIED. MODIFIED means the file diverged from the bundled copy — expected if you edit the entry file, otherwise a signal to run update.