#!/usr/bin/env python3
"""Write README.md for each CyberData 2 tier from its stats.json (every number computed, none typed by hand)."""
import json, os
HERE = os.path.dirname(os.path.abspath(__file__)); OUT = os.path.join(HERE, "out")
TIERS = ["small", "medium", "large", "full"]; NAME = {t: f"CyberData 2 {t.capitalize()}" for t in TIERS}; REPO = {t: f"VertexAGI/cyberdata-2-{t}" for t in TIERS}
ST = {t: json.load(open(os.path.join(OUT, f"cyberdata-2-{t}", "stats.json"))) for t in TIERS}
GOALS = [("Writing secure code and detection rules (fix, rewrite, write-a-rule)", {"sigma_write", "detection_rule_write", "secure_code_fix", "code_fix", "cwe_code_fix"}),
         ("Finding vulnerabilities (code review, weakness identification)", {"code_review_vulnerable", "code_review_patched", "cwe_code_weakness"}),
         ("Cyber reasoning (step-by-step vulnerability analysis with a verdict)", {"reasoning_vulnerability_detection"}),
         ("Agentic coding and tool use (security and software-engineering agents)", {"agent_security", "agent_swe", "agent_appsec_step"})]
SRC = [
 ("mitre/cwe", "MITRE CWE", "authoritative-structured", "MITRE CWE terms of use (royalty-free; keep the MITRE copyright notice)", "Weakness definitions, mitigations, detection methods, and the entries' own bad/good code examples"),
 ("mitre/capec", "MITRE CAPEC", "authoritative-structured", "MITRE CAPEC terms of use (royalty-free; keep the MITRE copyright notice)", "Attack-pattern descriptions, prerequisites, consequences, mitigations"),
 ("mitre/attack", "MITRE ATT&CK (enterprise)", "authoritative-structured", "MITRE ATT&CK terms of use (royalty-free; keep the MITRE copyright notice)", "Techniques, mitigations, detection analytics, groups, software, campaigns"),
 ("sigmahq/sigma", "SigmaHQ detection rules", "authoritative-structured", "Detection Rule License 1.1 (attribution to the rule authors, kept inside each rule)", "Real rules: write a rule from a description, explain a rule"),
 ("cisa/kev", "CISA Known Exploited Vulnerabilities", "authoritative-structured", "US-government work, public domain", "Exploited-in-the-wild status and required action per CVE"),
 ("primevul", "PrimeVul (paired vulnerable/fixed C/C++ functions)", "authoritative-structured", "MIT (train + valid pairs only; the test pairs are never used)", "Review a vulnerable function, review its patched version, fix it"),
 ("hitoshura25/cvefixes", "CVEfixes (real CVE fix commits, many languages)", "authoritative-structured", "Apache-2.0 per the Hub listing (the original CVEfixes release is CC BY 4.0)", "The same three code tasks across PHP/Python/JavaScript/Java/Go/Ruby/C/C++ and others"),
 ("Leopo1d/OpenVul-rejection-sampling", "OpenVul rejection-sampling vulnerability reasoning (Leopo1d)", "reasoning-verified", "Apache-2.0 (reasoning distilled from DeepSeek-R1-0528 by the dataset's authors)", "Step-by-step reasoning about whether C/C++ code is vulnerable, kept only when the verdict matched the label; vulnerable and patched versions in pairs"),
 ("mrmoor/cyber-threat-intelligence", "Annotated threat-report corpus", "human-annotated", "CC-BY-4.0 per the Hub tag (the dataset card has no text)", "Entity extraction and relationship listing from real threat-report excerpts"),
 ("reloading0101/threat-intelligence-dataset", "CTI instruction dataset (reloading0101)", "grounded-third-party", "CC-BY-4.0", "CVE/ATT&CK/KEV/Sigma-grounded threat-intelligence instructions and follow-ups; its authors state every claim is checked against the source"),
 ("nuhmanpk/cybersecurity-controls-instructions", "NIST SP excerpt instructions (nuhmanpk)", "nist-excerpt", "CC-BY-4.0 (source documents are NIST publications)", "Answers grounded in excerpts of NIST SP 800-series documents"),
 ("Humanlearning/CyberSecurity_OWASP-sft-dataset", "OWASP defensive repair trajectories (Humanlearning)", "verified-executed", "Apache-2.0", "Agent steps from episodes that were executed and reward-verified in a local environment (successful episodes only, no anti-cheat flags)"),
 ("Trendyol/Trendyol-Cybersecurity-Instruction-Tuning-Dataset", "Trendyol cybersecurity instructions", "third-party-synthetic", "Apache-2.0", "AI-written defensive Q&A, filtered (see below)"),
 ("AlicanKiraz0/Cybersecurity-Dataset-Fenrir-v2.1", "Fenrir v2.1", "third-party-synthetic", "Apache-2.0", "AI-written defensive Q&A, filtered, de-duplicated against Trendyol"),
 ("CyberNative/Code_Vulnerability_Security_DPO", "CyberNative code vulnerability pairs", "third-party-synthetic", "Apache-2.0", "Review vulnerable code and write the safer version"),
 ("jcordon5/cybersecurity-rules", "YARA / Suricata rules Q&A", "third-party-synthetic", "Apache-2.0", "Write a YARA or Suricata rule"),
 ("agentforge", "0xKitkat/AgentForge-1152 (security split)", "agent-trajectories", "Apache-2.0", "Defensive security-agent trajectories with tool use"),
 ("swe-hero", "nvidia/SWE-Hero-openhands-trajectories", "agent-trajectories", "CC-BY-4.0", "Software-engineering agent trajectories (OpenHands), length-capped at 120,000 characters"),
 ("openswe", "nvidia/Open-SWE-Traces (resolved runs only)", "agent-trajectories", "CC-BY-4.0", "Coding-agent trajectories whose patch was verified to fix the task (OpenHands / SWE-agent / mini-swe-agent), length-capped at 120,000 characters"),
]
PROVDESC = {"authoritative-structured": "real records (MITRE entries, Sigma rules, KEV entries, real CVE-fix code) turned into chat rows by fixed templates; every fact is copied or composed from a field of the record",
            "reasoning-verified": "reasoning traces written by DeepSeek-R1-0528 for the OpenVul authors and kept only when the final verdict matched the ground-truth label",
            "human-annotated": "expert-annotated threat-report text turned into extraction tasks by a template",
            "verified-executed": "agent steps whose episodes were executed against a local environment and passed a deterministic reward check",
            "grounded-third-party": "instruction sets written by their authors from real sources, who state their claims are checked against the source",
            "nist-excerpt": "answers grounded in excerpts of NIST publications",
            "third-party-synthetic": "AI-written Q&A by the dataset authors; the least reliable rows, so they are FILTERED: any row citing a CWE id that does not exist, or naming a CWE or ATT&CK technique with a name that does not match MITRE's data, is dropped (on 3,000-row samples roughly 15-19% of rows that cite ids had a nonexistent or mismatched one), as are refusals and duplicate questions",
            "agent-trajectories": "security-agent and software-engineering agent trajectories"}
fam = "| Size | Repo | Examples | Train | Valid |\n|---|---|---:|---:|---:|\n" + "\n".join(f"| {t.capitalize()} | [{REPO[t]}](https://huggingface.co/datasets/{REPO[t]}) | {ST[t]['rows']:,} | {ST[t]['train']:,} | {ST[t]['valid']:,} |" for t in TIERS)
for t in TIERS:
    st = ST[t]; n = st["rows"]; bt = st["by_task"]; used = 0; grows = []
    for g, ts in GOALS:
        c = sum(bt.get(x, 0) for x in ts); used += c; grows.append(f"| {g} | {c:,} | {100*c/n:.1f}% |")
    grows.append(f"| Security knowledge, Q&A and threat intelligence (supporting material) | {n-used:,} | {100*(n-used)/n:.1f}% |")
    prov = "\n".join(f"| `{k}` | {v:,} | {100*v/n:.1f}% | {PROVDESC.get(k, '')} |" for k, v in sorted(st["by_provenance"].items(), key=lambda x: -x[1]))
    src = "\n".join(f"| {d} | {st['by_source'].get(k, 0):,} | {100*st['by_source'].get(k, 0)/n:.1f}% | `{p}` | {lic} | {w} |" for k, d, p, lic, w in SRC if st["by_source"].get(k, 0))
    how = ("This is the **everything** release: every row from every source that passed our filters." if t == "full" else
           f"{NAME[t]} is a **nested subset** of the larger sizes: each source contributes a fixed share (capped at what exists), always the first rows of a fixed order, so Small is inside Medium, Medium inside Large and Large inside Full, and every row keeps the same train/valid split in every size. Shares are set by goal (agentic coding about 29%, writing code and finding vulnerabilities about 37%, reasoning about 9%, supporting knowledge about 21%), not by how much of each source exists.")
    card = f"""---
license: other
license_name: mixed-see-attribution
language:
- en
- code
task_categories:
- text-generation
- question-answering
tags:
- cybersecurity
- security
- vulnerability-detection
- secure-code
- agentic-coding
- reasoning
- mitre-attack
- cwe
- sigma
size_categories:
- {'100K<n<1M' if n >= 100000 else '10K<n<100K'}
pretty_name: {NAME[t]}
vertex_family: cyberdata
vertex_params: "N/A (dataset)"
vertex_purpose: "Fine-tuning for secure code, vulnerability finding, cyber reasoning and agentic coding"
vertex_result: "{n:,} examples from existing public datasets only; provenance tagged per row"
vertex_status: preview
vertex_name: "{NAME[t]}"
---

<div align="center">

# {NAME[t]}

**{n:,} chat examples for fine-tuning a model to write secure code, find vulnerabilities, reason about them, and work as a coding agent. Assembled entirely from existing public datasets; no model was run to write any of it.**

</div>

---

## The CyberData 2 family

{fam}

{how}

## What this size teaches

| Goal | Rows | Share |
|---|---:|---:|
{chr(10).join(grows)}

## Where every row comes from (`provenance`)

Each row has a provenance tag in `row_index.csv`, so you can train on a stricter subset (for example, drop `third-party-synthetic`).

| provenance | rows | share | what it means |
|---|---:|---:|---|
{prov}

## Sources

| Source | Rows | % | Provenance | License / terms | What it contributes |
|---|---:|---:|---|---|---|
{src}

### Considered and left out

- `trendmicro-ailab/Primus-Reasoning` and `Primus-Instruct`: gated (access request required).
- `rmems/incident-response-oncall-trajectories`: tagged Apache-2.0, but its own rights note says it is *not training data for any model-weight update*.
- `netgoat-ai/Koda-IDS-CyberReasoning`: inspected and rejected. After quality filtering only templated scenarios for one vendor's tool API remained.
- `ayshajavd/code-security-vulnerability-dataset`: mostly a repackaging of BigVul (no clear license), PrimeVul-derived samples and CyberNative, so it added little that was new.
- Benchmark sets (CyberMetric, MMLU computer security, CTI-Bench): kept out so they stay usable for evaluation; a scan found none of their questions verbatim here.

## Splits and checks

`train.jsonl` has {st['train']:,} rows and `valid.jsonl` has {st['valid']:,}. Rows derived from the same object (a CWE entry, a Sigma rule, a code-fix pair, an agent episode, a vulnerable/patched reasoning pair, a document chunk) always share one split. Checks run before release (`build_scripts/verify_sizes.py`): exact row counts; unique ids; strict nesting between sizes; the same split for every row in every size; every line parses with valid roles and an assistant last turn; no row mentions any of the 916 CVEs we hold out for a CVE-recall evaluation; no verbatim CyberMetric / MMLU-security question appears.

## Format

Each line is `{{"messages": [...]}}`, standard chat SFT format. Agent rows carry `tool_calls`; reasoning rows keep the source's `<think>...</think>` block followed by the final answer. `row_index.csv` has `id, source, task, provenance, split, group` per row.

```python
from datasets import load_dataset
ds = load_dataset("{REPO[t]}")
print(ds["train"][0]["messages"])
```

## Limitations

- **Vulnerability finding is supply-limited.** The real vulnerable-and-fixed code comes from PrimeVul, CVEfixes and the OpenVul reasoning set; there is no more openly licensed labeled data we trusted. Vulnerability detection is a hard task: training on these labels does not by itself guarantee good detection.
- **Reasoning covers one task.** The only verified reasoning set we found is vulnerability detection in C/C++. There is no verified reasoning data here for incident response or threat analysis.
- **Agent trajectories are length-capped** at 120,000 characters (about 30k tokens), so the longest runs are absent.
- Templated rows teach the answer format and the content of the records as written; they are not a verified knowledge base. In our tests none of the 8B base models we tried could recall facts about CVEs they had not seen, so for CVE-specific facts use lookup, not memory.
- PrimeVul and CVEfixes CWE labels come from NVD and are sometimes loose. The `third-party-synthetic` and `grounded-third-party` rows can still contain errors beyond the ids we can check.

## Licensing and attribution

A mixture of independently licensed sources (see the table). Required attribution: (c) The MITRE Corporation for CWE, CAPEC and ATT&CK content; SigmaHQ rule authors (Detection Rule License 1.1; author fields are kept in the rule text); CC-BY-4.0 sources (nvidia SWE-Hero and Open-SWE-Traces, reloading0101, nuhmanpk, mrmoor) must be credited as listed. The OpenVul reasoning was written by DeepSeek-R1-0528; check DeepSeek's terms for your use. No source is gated or carries a non-commercial restriction.
"""
    open(os.path.join(OUT, f"cyberdata-2-{t}", "README.md"), "w").write(card)
    print("card", t, len(card))