`raptor` लॉन्चर सत्र शुरू करने का अनुशंसित तरीका है, और यह किसी भी निर्देशिका से काम करता है -- यह RAPTOR इंस्टॉलेशन को हल करता है, उस निर्देशिका को याद रखता है जिससे आपने लॉन्च किया था (ताकि `/scan` जैसे कमांड उसी पर डिफ़ॉल्ट हों), प्री-फ्लाइट ट्रस्ट और प्रोजेक्ट जाँच चलाता है, कवरेज-ट्रैकिंग प्लगइन लोड करता है, और Claude Code को सौंपने से पहले वातावरण को साफ करता है। यह एक वैकल्पिक लक्ष्य पथ और `--project`, `--continue`, और `--model` जैसे फ्लैग भी लेता है -- `raptor --help` देखें।

रिपोजिटरी निर्देशिका के अंदर से सादा `claude` चलाना भी काम करता है -- Claude Code चेकआउट से RAPTOR का कॉन्फ़िगरेशन उठा लेता है -- लेकिन आप ऊपर लॉन्चर द्वारा किए गए सब कुछ छोड़ देते हैं: कोई प्री-फ्लाइट जाँच नहीं, कोई कवरेज ट्रैकिंग नहीं, और जो कमांड "उस निर्देशिका जिससे आपने यह चलाया" पर डिफ़ॉल्ट होते हैं, वे उसे नहीं देख सकते।

**महत्वपूर्ण:** RAPTOR अपना कॉन्फ़िगरेशन रिपोजिटरी निर्देशिका से लोड करता है। यदि आप किसी अन्य निर्देशिका से `claude` चलाते हैं, तो आपको सादा Claude Code मिलता है, RAPTOR नहीं। `raptor` लॉन्चर इस विफलता मोड को पूरी तरह से टाल देता है।

### विकल्प 2: कंटेनर में चलाएँ (अनुशंसित)

कंटेनरों का उपयोग करना एक सामान्य सुरक्षा अभ्यास है ताकि एजेंटों को आपके फाइलसिस्टम के उन क्षेत्रों तक पहुँचने से रोका जा सके जिन तक आप नहीं चाहते कि वे पहुँचें, साथ ही किसी भी दुर्भावनापूर्ण कोड (जैसे सप्लाई-चेन हमले के माध्यम से) के विस्फोट की सीमा को सीमित किया जा सके जो निष्पादित हो सकता है। इमेज बड़ी है (लगभग 6 GB)। यह Microsoft Python 3.12 devcontainer से शुरू होती है और स्थैतिक विश्लेषण, फ़ज़िंग, और ब्राउज़र ऑटोमेशन टूलिंग जोड़ती है।

आप एक पूर्व-निर्मित इमेज खींच सकते हैं:```bash
docker pull danielcuthbert/raptor:latest

इमेज RAPTOR फ्रेमवर्क (यह रिपॉजिटरी) को स्टार्टअप पर `/workspaces/raptor` में माउंट होने की अपेक्षा करती है। आप वैकल्पिक रूप से स्थानीय विश्लेषण के लिए एक टारगेट फोल्डर माउंट कर सकते हैं।

कंटेनर शुरू करने के लिए:```bash
docker run -it \
  -v "$(pwd):/workspaces/raptor" \
  raptor:latest

अगर आपको `rr` डिटर्मिनिस्टिक डिबगर चाहिए तो `--privileged` जोड़ें।

VS Code devcontainers भी समर्थित हैं। किसी टारगेट फ़ोल्डर को माउंट करने के लिए, उसे `.devcontainer/devcontainer.json` के `mounts` सेक्शन में जोड़ें:```jsonc
"mounts": [
  // ...existing entries...
  "source=/path/to/target-folder,target=/workspaces/target,type=bind,consistency=cached"
]

चाहे जो भी हो, एक बार जब आप कंटेनर के अंदर हों, तो शुरू करने के लिए `raptor` चलाएँ।

---

## पहली बार चलाने पर क्या उम्मीद करें

सबसे आसान काम जो आप कर सकते हैं:```
/scan /path/to/code

यह पूरी पाइपलाइन चलाता है: स्कैन, डीडुप्लिकेशन, फिर प्रत्येक निष्कर्ष को सत्यापन चरणों (A-F) से गुज़ारता है। मध्यम आकार के कोडबेस पर ~50 निष्कर्षों के साथ, 10-30 मिनट और विश्लेषण-परत LLM लागत में $2-8 की उम्मीद करें (मॉडल पर निर्भर करता है)। डिफ़ॉल्ट लागत सीमा $10 प्रति रन है; `--max-cost-usd` से समायोजित करें।

**लागत नोट:** Claude Code ऑर्केस्ट्रेशन परत आपके Claude सब्सक्रिप्शन का उपयोग करती है। विश्लेषण डिस्पैच परत अलग LLM API कॉल करती है जो प्रति टोकन बिल होती हैं। यदि आप केवल Claude Code को विश्लेषण मॉडल के रूप में उपयोग करते हैं (डिफ़ॉल्ट), तो आपके सब्सक्रिप्शन से परे कोई अतिरिक्त लागत नहीं है। यदि आप बाहरी मॉडल (OpenAI, Gemini, आदि) कॉन्फ़िगर करते हैं, तो वे API कॉल उन प्रदाताओं को बिल की जाती हैं।

---

## सुरक्षा मॉडल

RAPTOR LLM-जनित कोड चलाता है और अविश्वसनीय रिपॉजिटरी का विश्लेषण करता है। अविश्वसनीय सामग्री को संभालने वाले सबप्रोसेस Linux नेमस्पेस, Landlock और seccomp का उपयोग करके सैंडबॉक्स किए जाते हैं। सैंडबॉक्स नेटवर्क एक्सेस को ब्लॉक करता है, फाइलसिस्टम दृश्यता को प्रतिबंधित करता है, और संसाधन खपत को सीमित करता है। पूर्ण खतरा मॉडल और कॉन्फ़िगरेशन के लिए `docs/sandbox.md` देखें।

लॉन्चर श्रृंखला में कोड इंजेक्ट कर सकने वाले पर्यावरण चर स्टार्टअप पर हटा दिए जाते हैं (`core/security/_dangerous_env_strip.sh`)। स्कैन किए गए रिपॉजिटरी के फ़ाइल पथ कभी भी शेल स्ट्रिंग्स में इंटरपोलेट नहीं होते — सभी सबप्रोसेस कॉल सूची-आधारित तर्कों का उपयोग करते हैं।

---

## RAPTOR क्या कर सकता है

| कमांड | यह क्या करता है | स्थिति |
|---------|-------------|--------|
| `/agentic` | पूर्ण स्वायत्त वर्कफ़्लो: स्कैन, सत्यापन, एक्सप्लॉइट, पैच | स्थिर |
| `/scan` | Semgrep और CodeQL के साथ स्थैतिक विश्लेषण | स्थिर |
| `/understand` | हमले की सतह मैप करें, डेटा प्रवाह ट्रेस करें, भेद्यता वेरिएंट खोजें | स्थिर |
| `/binary` | ब्लैक-बॉक्स बाइनरी जांच, रनटाइम साक्ष्य, ग्राफ़ क्वेरी और हैंडऑफ़ | बीटा |
| `/ghidra` | Ghidra RE ब्रिज: `.gpr` प्रोजेक्ट अटैच/इम्पोर्ट करें, क्रॉस-वर्जन डिफ़, निष्कर्ष निर्यात | बीटा |
| `/audit` | परिकल्पना-संचालित, टूल-आधारित व्यवस्थित कोड समीक्षा | बीटा |
| `/review` | ऑडिट स्थिति क्वेरी करें: निष्कर्ष, अंतराल, कवरेज, ऑपरेटर नोट्स | स्थिर |
| `/annotate` | प्रति-फ़ंक्शन मुक्त-रूप गद्य एनोटेशन संलग्न करें (ऑपरेटर समीक्षा नोट्स) | स्थिर |
| `/validate` | बहु-चरण शोषण-क्षमता सत्यापन पाइपलाइन (चरण 0-F) | स्थिर |
| `/diagram` | `/understand` और `/validate` JSON आउटपुट से Mermaid दृश्य मानचित्र | बीटा |
| `/codeql` | SMT डेटाफ़्लो प्री-स्क्रीनिंग के साथ केवल-CodeQL गहन विश्लेषण | स्थिर |
| `/analyze` | पुनः स्कैन किए बिना LLM के साथ मौजूदा SARIF निष्कर्षों का विश्लेषण करें | स्थिर |
| `/sca` | सॉफ़्टवेयर संरचना विश्लेषण: निर्भरताएँ, सलाह, आपूर्ति-श्रृंखला संकेत, SBOM और फिक्स | बीटा |
| `/cve-diff` | OSV, NVD, GitHub और GitLab में CVE के लिए फिक्स कमिट खोजें और डिफ़ करें | बीटा |
| `/cve-env` | CVE के प्रभावित एप्लिकेशन को उसके प्री-पैच संस्करण पर चलाने वाला Docker वातावरण बनाएं और सत्यापित करें | प्रायोगिक |
| `/exploit` | प्रूफ-ऑफ-कॉन्सेप्ट एक्सप्लॉइट कोड उत्पन्न करें | बीटा |
| `/patch` | पुष्टि की गई भेद्यताओं के लिए सुरक्षित पैच उत्पन्न करें | बीटा |
| `/fuzz` | AFL++ के साथ बाइनरी फ़ज़िंग और क्रैश विश्लेषण | स्थिर |
| `/crash-analysis` | C/C++ क्रैश के लिए स्वायत्त रूट-कॉज़ विश्लेषण | स्थिर |
| `/oss-forensics` | GitHub रिपॉजिटरी के लिए साक्ष्य-समर्थित फोरेंसिक जांच | स्थिर |
| `/project` | रन व्यवस्थित करने और समय के साथ निष्कर्ष ट्रैक करने के लिए नामित वर्कस्पेस | स्थिर |
| `/describe` | लक्ष्य का वर्णन करें: भाषा मिश्रण, बिल्ड सिस्टम, टूल अंतराल, लागत अनुमान (केवल-पढ़ने) | स्थिर |
| `/threat-model` | प्रति-प्रोजेक्ट खतरा मॉडल बनाएं, निरीक्षण करें और बनाए रखें | स्थिर |
| `/sage` | स्थायी मेमोरी परत (स्टोर, रिकॉल, लिंक, पुष्टि) | स्थिर |
| `/ask` | किसी भी कॉन्फ़िगर किए गए LLM मॉडल को मुक्त-रूप प्रॉम्प्ट भेजें | स्थिर |
| `/scorecard` | निर्णय वर्गों में प्रति-मॉडल विश्वसनीयता का निरीक्षण करें | स्थिर |
| `/frida` | Frida के माध्यम से गतिशील इंस्ट्रूमेंटेशन | अल्फा |
| `/web` | वेब एप्लिकेशन स्कैनिंग: क्रॉल, ffuf/nuclei एकीकरण, ओरेकल-सत्यापित इंजेक्शन, ब्लाइंड SSRF कॉलबैक | बीटा |

---

## पाइपलाइन कैसे काम करती है

एक प्रोजेक्ट बनाकर शुरू करें ताकि आपके सभी रन एक ही स्थान पर आएँ:```
/project create myapp --target /path/to/code   # create a project first
/project use myapp                             # set it as active
/understand --map                              # map the attack surface
/agentic --threat-model --validate             # map, model, scan, validate
/project findings                              # review everything in one place

`/understand` स्कैनिंग की एक भी लाइन चलने से पहले एंट्री पॉइंट्स, ट्रस्ट बाउंड्रीज़ और सिंक्स का कॉन्टेक्स्ट मैप बनाता है। `/agentic` फिर Semgrep और CodeQL चलाता है, निष्कर्षों को डीडुप्लिकेट करता है, और exploitation-validator पद्धति का उपयोग करके सत्यापन के लिए प्रत्येक को भेजता है:

`--threat-model` के साथ, RAPTOR पहले मैप चलाता है, `threat-model.json` और `THREAT_MODEL.md` बनाता है यदि प्रोजेक्ट में वे पहले से नहीं हैं, फिर एक कॉम्पैक्ट संस्करण `/understand`, स्वायत्त विश्लेषण और `/validate` में फीड करता है। मौजूदा प्रोजेक्ट थ्रेट मॉडल संरक्षित रहते हैं जब तक आप `--threat-model-refresh` पास नहीं करते; पुराने फ़ॉलबैक मैप अस्वीकार कर दिए जाते हैं जब तक आप स्पष्ट रूप से `--threat-model-use-stale` पास नहीं करते। यह मैप किए गए अनचेक किए गए फ्लो को उम्मीदवार SARIF में भी बदल देता है ताकि स्कैनर की चूक रन को खत्म न कर दे। यह ऑपरेटर-स्वामित्व वाला कॉन्टेक्स्ट है, जादुई प्रमाण नहीं: निष्कर्षों को अभी भी कोड साक्ष्य या ओरेकल-समर्थित पुष्टि की आवश्यकता होती है। देखें `docs/threat-model.md`।

- स्टेज A: क्या पैटर्न वास्तव में एक कमजोरी है, या क्या टूल पैटर्न-मैचिंग शोर कर रहा है?
- स्टेज B: एक हमलावर को उस तक पहुँचने के लिए क्या चाहिए, और रास्ते में क्या बाधाएँ हैं?
- स्टेज C: क्या कोड पथ वास्तव में मौजूद है? क्या बाहर से उस तक पहुँचा जा सकता है?
- स्टेज D: अंतिम निर्णय — क्या यह टेस्ट कोड है, क्या इसे अवास्तविक पूर्वशर्तों की आवश्यकता है, क्या मॉडल हेजिंग कर रहा है?
- स्टेज E: बाइनरी एक्सप्लॉइट व्यवहार्यता (जब एक संकलित आर्टिफैक्ट उपलब्ध हो)
- स्टेज F: स्व-समीक्षा — क्या किसी पिछले चरण ने हेज किया या खुद का खंडन किया?

जो निष्कर्ष सत्यापन पास करते हैं, उनके लिए एक्सप्लॉइट PoC और पैच उत्पन्न किए जाते हैं। साझा मूल कारणों और हमले की श्रृंखलाओं को खोजने के लिए अंत में एक क्रॉस-फाइंडिंग विश्लेषण चलता है।

`/validate` इसी पाइपलाइन को एक स्टैंडअलोन चरण के रूप में चलाता है यदि आपके पास पिछले स्कैन से पहले से निष्कर्ष हैं।

एक संकलित आर्टिफैक्ट के लिए, `/binary <path>` अब ऑपरेटर पर कच्चे रिवर्स-इंजीनियरिंग आर्टिफैक्ट्स का ढेर डालने के बजाय एक साक्ष्य-प्रथम जाँच चलाता है। इसके नीचे यह अभी भी फ़ाइल मेटाडेटा, इम्पोर्ट्स और radare2 xrefs से SHA-256-बाउंड मैनिफेस्ट, साक्ष्य लेजर, कॉन्टेक्स्ट मैप, चेकलिस्ट और SQLite ग्राफ बनाता है। Mach-O ऐप्स को स्लाइस इन्वेंट्री, बंडल मेटाडेटा और Objective-C / Swift क्लास सेलेक्टर भी मिलते हैं; उच्च-मूल्य वाला स्यूडोकोड रन के अंदर गायब होने के बजाय संग्रहीत रहता है। PE DLL एक्सपोर्ट्स, Windows ड्राइवर डिस्पैचर्स और Linux कर्नेल-मॉड्यूल ioctl हैंडलर्स को भी उनके अपने इनग्रेस उम्मीदवारों के रूप में संभाला जाता है, जिसमें PE आर्किटेक्चर अनुमान लगाने के बजाय COFF हेडर से पढ़ा जाता है। जाँच परत फिर उस ग्राफ को क्वेरी करती है, सामान्य सिंक लीड्स से पहले बाहरी इनग्रेस को रैंक करती है, घोषित हेल्पर/सिबलिंग बाइनरीज़ खोजती है, और तथ्यों, संरचनात्मक अनुमानों और अप्रमाणित परिकल्पनाओं में विभाजित एक कॉम्पैक्ट रिपोर्ट लिखती है। Frida अवलोकन, फ़ज़ क्रैश गवाह, स्पष्ट Z3 जाँच और बाइनरी डिफ्स बाद में मजबूत साक्ष्य जोड़ सकते हैं। RAPTOR बाउंडेड इनग्रेस-टू-पार्सर उम्मीदवारों को पुनर्प्राप्त करने के लिए आवश्यक आंतरिक कॉल ग्राफ भी रखता है, ताकि एक ऐप कॉलबैक को उस आंतरिक फ़ंक्शन तक सीमित किया जा सके जो वास्तव में `XML_Parse`, `d2i_X509`, `jpeg_read_header` या किसी अन्य वास्तविक पार्सर सतह को कॉल करता है, बिना यह दिखावा किए कि यह टेंट प्रूफ है। `/binary trace-parser <run-dir>` स्पष्ट गतिशील अनुवर्ती है: यह संकीर्ण Frida पार्सर ट्रेस चलाता है, फिर उसी कॉन्टेक्स्ट मैप, हैंडऑफ़, ग्राफ और जाँच रिपोर्ट को जगह पर रीफ्रेश करता है। `/binary investigate --active` पहले मैप करता है और केवल तभी एक वास्तविक फ़ज़ अभियान शुरू करता है जब एक ठोस हार्नेस बाउंड्री मौजूद हो; ऐप, DLL और ड्राइवर लक्ष्यों को इसके बजाय एक हार्नेस या स्नैपशॉट चरण मिलता है। `/binary harness` चुने गए इनग्रेस के लिए एक साक्ष्य-समर्थित हार्नेस स्पेक लिखता है और केवल तभी उम्मीदवार स्रोत उत्सर्जित करता है जब ABI या IOCTL अनुबंध स्पष्ट हो। यह "`memcpy` मौजूद है" से "यह एक्सप्लॉइटेबल है" तक अपना रास्ता नहीं बनाता: इम्पोर्ट्स, सेलेक्टर और कॉल एज तब तक उम्मीदवार बने रहते हैं जब तक कोई यांत्रिक चीज़ अधिक साबित नहीं करती। देखें `docs/binary-analysis.md`।

---

## सॉफ्टवेयर कंपोज़िशन विश्लेषण

`/sca` किसी प्रोजेक्ट के डिपेंडेंसी और सप्लाई-चेन पक्ष का विश्लेषण करता है। यह केवल requirements-फ़ाइल CVE लुकअप नहीं है: RAPTOR मैनिफेस्ट, लॉकफ़ाइल्स, इनलाइन इंस्टॉल कमांड, वर्कफ़्लो डिपेंडेंसी और कंटेनर/बेस-इमेज पैकेज स्रोतों की खोज करता है, फिर उन्हें एक एकल डिपेंडेंसी दृश्य में सामान्यीकृत करता है।

स्कैन डिपेंडेंसी को OSV एडवाइज़री, CISA KEV, EPSS, CISA Vulnrichment/SSVC, रीचेबिलिटी, एक्सप्लॉइट-साक्ष्य सिग्नल, हाइजीन जाँच, सप्लाई-चेन ह्यूरिस्टिक्स, लाइसेंस-पॉलिसी निष्कर्षों और वैकल्पिक LLM समीक्षा/ट्राइएज से समृद्ध करता है। यह RAPTOR-नेटिव निष्कर्षों के साथ-साथ SBOM और CI-अनुकूल आउटपुट उत्सर्जित करता है:

- `findings.json` - विहित RAPTOR निष्कर्ष
- `report.md` - मानव-पठनीय सारांश
- `sbom.cdx.json` - VEX डेटा के साथ CycloneDX SBOM
- `findings.sarif` - GitHub/GitLab कोड-स्कैनिंग आउटपुट

सामान्य कमांड:```bash
python3 raptor.py sca --repo /path/to/project
python3 raptor.py sca --repo /path/to/project --no-llm
python3 raptor.py sca --repo /path/to/project --fail-on-severity high --fail-on-kev
python3 raptor.py sca --repo /path/to/project fix
python3 raptor.py sca check PyPI django 4.2.10

एक बार पॉप्युलेट हो जाने पर, स्कैनर पैक आईडी को स्थानीय फ़ाइलों में हल करता है और कोई नेटवर्क कॉल नहीं होती। कैश के बिना, RAPTOR स्कैन समय पर semgrep.dev से रजिस्ट्री पैक लाने का प्रयास करेगा; यदि ऑफ़लाइन है, तो यह बिना कैश किए गए पैक को सुरक्षित रूप से छोड़ देता है और केवल कस्टम नियमों के साथ चलता है।

CodeQL को प्रारंभिक सेटअप के दौरान ही CLI और क्वेरी पैक डाउनलोड करने के लिए नेटवर्क एक्सेस की आवश्यकता होती है। एक बार इंस्टॉल हो जाने पर यह ऑफ़लाइन चलता है।

---

## कस्टम नियम

RAPTOR 200 से अधिक कस्टम स्टैटिक विश्लेषण नियमों के साथ आता है, जिन्हें गलत सकारात्मक परिणामों को खत्म करने के लिए प्रतिकूल रूप से परीक्षण किया गया है:

- **Semgrep (145 नियम)** — Python, Go, Java, और JS/TS के लिए टेंट-ट्रैकिंग और पैटर्न नियम। SQLi, XSS, SSRF, SSTI, कमांड इंजेक्शन, डिसीरियलाइज़ेशन, XXE, LDAP/NoSQL इंजेक्शन, पाथ ट्रैवर्सल, ओपन रीडायरेक्ट, लॉग/हेडर इंजेक्शन, eval इंजेक्शन, ReDoS, प्रोटोटाइप पोल्यूशन, JWT मिसकॉन्फ़िगरेशन, कमज़ोर क्रिप्टो, असुरक्षित TLS, और हार्डकोडेड सीक्रेट्स को कवर करता है।
- **Coccinelle (63 नियम)** — C/C++ के लिए संरचनात्मक मिलान। मेमोरी सुरक्षा (डबल फ्री, यूज़-आफ्टर-फ्री, नॉन-बेस पॉइंटर का फ्री, स्टैक ऐरे का फ्री, mmap की गई मेमोरी, यूज़-आफ्टर-क्लोज़), इंटीजर बग्स (ओवरफ्लो, साइन एक्सटेंशन, डबल sizeof), रिसोर्स लीक (popen/fclose बेमेल, fdopendir डबल क्लोज़), बफ़र हैंडलिंग (NUL के बिना strncpy, copy_user आकार बेमेल, malloc/strlen ऑफ-बाय-वन), सिग्नल हैंडलर सुरक्षा, API दुरुपयोग (fcntl फ़्लैग डोमेन, SIGKILL/SIGSTOP, डबल बाइट-स्वैप, inet_ntoa स्टैटिक बफ़र), कंपाइलर डेड-स्टोर एलिमिनेशन, कर्नेल IS_ERR/PTR_ERR भ्रम, फ़ॉर्मेट स्ट्रिंग इंजेक्शन, TOCTOU रेस, और बहुत कुछ।
- **CodeQL (8 क्वेरी)** — C++ (फ़ॉर्मेट स्ट्रिंग इंजेक्शन, इंटीजर ट्रंकेशन, यूज़-आफ्टर-मूव, इटरेटर इनवैलिडेशन) और Java (XXE, असुरक्षित डिसीरियलाइज़ेशन, लॉग इंजेक्शन, Spring SSRF) के लिए इंटरप्रोसीजरल टेंट ट्रैकिंग।

नियमों को सीधे ब्राउज़ करें: `engine/semgrep/rules/`, `engine/coccinelle/rules/`, `engine/codeql/queries/`। ये Semgrep रजिस्ट्री पैक के पूरक हैं जिन्हें RAPTOR खींचता है (`p/security-audit`, `p/owasp-top-ten`, `p/secrets` हमेशा; प्रति-पॉलिसी-ग्रुप पैक जैसे `p/command-injection`, `p/jwt`, `p/xss` शीर्ष पर) — ओवरलैप न्यूनतम है।

---

## RAPTOR खुद की जाँच कैसे करता है

RAPTOR अपने स्वयं के सुरक्षा टूलिंग का काफी हिस्सा डॉगफूड करता है, लेकिन यह स्पष्ट होना उचित है कि वास्तव में PR को क्या रोकता है और क्या केवल पृष्ठभूमि में चलता है ताकि हम ईमानदार रहें। इसमें से कुछ एक कठोर गेट है, कुछ एक निर्धारित जाँच है, और कुछ केवल एक बेंचमार्क है जिसे हम रखते हैं ताकि हम बता सकें कि हमने चीज़ों को कब बदतर बनाया है। वास्तविक पैरामीटर और जाँचों को दोहराने के तरीके सहित अधिक विस्तृत विवरण, `docs/ci-controls.md` में है।

| नियंत्रण | यह क्या जाँचता है | ट्रिगर | कॉन्फ़िग / साक्ष्य |
|---|---|---|---|
| Ruff | Python सहीता लिंटिंग (`F401`, `F811`, `F821`, `F841`) | PR डिफ़ गेट, साथ ही साप्ताहिक पूर्ण-ट्री ऑडिट | `pyproject.toml`, `.github/workflows/lint.yml` |
| Pytest | तेज़ यूनिट/इंटीग्रेशन सीमाएँ, सबसिस्टम-विशिष्ट टियर (इम्पोर्ट-ग्राफ डिस्पैच के माध्यम से), प्रॉम्प्ट-एनवलप ऑडिट | PRs, `main` पर पुश, मर्ज क्यू, निर्धारित पूर्ण सुइट | `pytest.ini`, `.github/workflows/tests.yml`, `.github/workflows/nightly.yml` |
| CodeQL Advanced | इम्पोर्ट-ग्राफ स्कोप संकुचन के साथ Python, C/C++, और GitHub Actions कोड स्कैनिंग | PRs, `main` पर पुश, मर्ज क्यू, साप्ताहिक शेड्यूल | `.github/workflows/codeql.yml`, `.github/codeql/codeql-config.yml` |
| वर्कफ़्लो हार्डनिंग | SHA-पिन किए गए थर्ड-पार्टी Actions, न्यूनतम-विशेषाधिकार अनुमतियाँ, कमांड मेटाडेटा लिंटिंग | हर वर्कफ़्लो परिवर्तन और हर लिंट रन | `.github/workflows/`, `.github/scripts/check_command_metadata.py` |
| कॉर्पस लेबल लिंट | कॉर्पस लेबल स्कीमा सत्यापन और अपस्ट्रीम पिन सत्यापन का ऑडिट | PRs (बदले गए लेबल), साप्ताहिक पूर्ण स्वीप | `.github/workflows/corpus-labels.yml` |
| RAPTOR SCA PR गेट | PR द्वारा शुरू की गई निर्भरता और सप्लाई-चेन रिग्रेशन | मैनिफ़ेस्ट / लॉकफ़ाइल / वर्कफ़्लो परिवर्तन | `.github/workflows/sca-pr-gate.yml` |
| RAPTOR SCA सेल्फ-बंप | यांत्रिक निर्भरता हार्डनिंग और सुरक्षित अपग्रेड प्रस्ताव | साप्ताहिक शेड्यूल, मैनुअल रन | `.github/workflows/sca-self-bump.yml` |
| SCA समझौता कॉर्पस | क्या ज्ञात निर्भरता समझौते अभी भी अपेक्षित सिग्नल ट्रिगर करते हैं | साप्ताहिक शेड्यूल, प्रासंगिक PR परिवर्तन | `test/data/sca-e2e/compromise-corpus/`, `.github/workflows/sca-compromise-check.yml` |
| मिसवायरिंग स्कैन | डेड-कोड / गलत-कॉल पहचान, env-var दस्तावेज़ीकरण बहाव, शब्दावली-सूची गार्डरेल, वैकल्पिक-डिप इम्पोर्ट लिंट | दैनिक शेड्यूल | `.github/workflows/miswiring-scan.yml`, `.github/scripts/*_baseline.json` |
| SCA कैलिब्रेशन + स्ट्रेस कॉर्पस | क्या जोखिम स्कोरिंग और पार्सर कवरेज समय के साथ बहाव करते हैं | साप्ताहिक / मासिक निर्धारित जॉब | `packages/sca/data/calibration/`, `.github/workflows/refresh-sca-calibration.yml`, `.github/workflows/sca-stress-sweep.yml` |
| डेटाफ़्लो कॉर्पस | वैलिडेटर व्यवहार के लिए प्रेसिज़न / रिकॉल / FP-श्रेणी ट्रैकिंग | डेवलपर-रन बेंचमार्क और कॉर्पस परीक्षण | `core/dataflow/corpus/`, `core/dataflow/scripts/corpus-metrics` |
| CI नियंत्रण दस्तावेज़ गार्ड | दस्तावेज़ित पथ मौजूद हैं, ruff कॉन्फ़िग मेल खाता है, README दस्तावेज़ से लिंक करता है | PRs | `.github/tests/test_ci_controls_docs.py` |

वर्तमान में लागू नहीं: `mypy` `requirements-dev.txt` में इंस्टॉल है लेकिन कुछ भी ब्लॉक नहीं करता; Ruff फ़ॉर्मेटिंग लागू नहीं है; Semgrep RAPTOR की स्कैनर सतह का हिस्सा है, लेकिन हमारे पास अभी तक एक समर्पित "RAPTOR को RAPTOR से स्कैन करें" Semgrep वर्कफ़्लो नहीं है।

---

## एक अलग LLM का उपयोग करना

RAPTOR में दो अलग-अलग मॉडल परतें हैं, और कुछ भी बदलने से पहले यह जानना उचित है कि दोनों कैसे काम करते हैं।

**ऑर्केस्ट्रेशन परत** हमेशा Claude Code है। CLAUDE.md, स्किल्स, और कमांड सभी Claude Code निर्देशों के रूप में चलते हैं। RAPTOR को ऑर्केस्ट्रेट करने वाले Claude मॉडल को बदलने के लिए, Claude Code के `--model` फ़्लैग या सत्र के अंदर `/model` कमांड का उपयोग करें।

**विश्लेषण डिस्पैच परत** वह LLM है जो व्यक्तिगत भेद्यता निष्कर्षों का विश्लेषण करता है। यह ऑर्केस्ट्रेशन परत से अलग है और कोई भी समर्थित प्रदाता हो सकता है। इसे `~/.config/raptor/models.json` में कॉन्फ़िगर करें:```json
{
  "models": [
    {
      "provider": "anthropic",
      "model": "claude-opus-4-6",
      "api_key": "sk-ant-...",
      "role": "analysis"
    },
    {
      "provider": "openai",
      "model": "gpt-5.4",
      "api_key": "sk-...",
      "role": "analysis"
    },
    {
      "provider": "anthropic",
      "model": "claude-sonnet-4-6",
      "api_key": "sk-ant-...",
      "role": "aggregate"
    }
  ]
}

| भूमिका | यह क्या करता है |
|------|-------------|
| `analysis` | प्रत्येक निष्कर्ष को मान्य और विश्लेषित करता है (चरण A-F) |
| `code` | एक्सप्लॉइट PoC और पैच कोड लिखता है |
| `consensus` | सही सकारात्मक पर दूसरी राय का मतदान |
| `aggregate` | वैकल्पिक। निर्धारक मल्टी-मॉडल सहसंबंध के शीर्ष पर LLM-लिखित कथात्मक संश्लेषण, `aggregation.json` और अंतिम `agentic-report.md` में लिखा गया |
| `fallback` | उपयोग किया जाता है यदि प्राथमिक मॉडल विफल हो जाता है या दर सीमा हिट करता है |

यदि कोई भूमिका निर्धारित नहीं है, तो सूची का पहला मॉडल सब कुछ संभालता है। मल्टी-मॉडल
स्रोत-कोड विश्लेषण के लिए, दो या अधिक `analysis` मॉडल कॉन्फ़िगर करें — आपको
डिफ़ॉल्ट रूप से निर्धारक सहसंबंध मिलेगा। `aggregate` भूमिका वैकल्पिक है और इसके शीर्ष पर एक
LLM-लिखित सारांश जोड़ती है:```bash
python3 raptor.py agentic --repo /code \
  --model claude-opus-4-6 \
  --model gpt-5.4 \
  --aggregate claude-sonnet-4-6

Ollama विश्लेषण के लिए काम करता है लेकिन अविश्वसनीय एक्सप्लॉइट और पैच कोड उत्पन्न करता है। कोड जनरेशन कार्यों के लिए, एक फ्रंटियर मॉडल का उपयोग करें।

### फास्ट-टियर शॉर्ट-सर्किट + मॉडल स्कोरकार्ड

जब आपके विश्लेषण-टियर मॉडल का एक ही-प्रदाता वाला सस्ता सहोदर होता है (Anthropic Opus → Haiku, OpenAI 5.x → 4o-mini, Gemini Pro → Flash-Lite, Mistral Large → Small), RAPTOR इसे उन कंज्यूमर्स पर प्रीफिल्टर के रूप में उपयोग करेगा जो सब्सट्रेट से जुड़ते हैं (आज codeql; SCA और अन्य फॉलो-अप के रूप में आते हैं)। सस्ता मॉडल केवल **आत्मविश्वासपूर्ण गलत सकारात्मक** पर शॉर्ट-सर्किट करता है; अस्पष्ट मामले और आत्मविश्वासपूर्ण-टीपी हमेशा पूर्ण विश्लेषण चलाते हैं। विश्वास प्रति `(model, decision_class)` सेल जमा होता है — RAPTOR सस्ते-बनाम-पूर्ण सहमति दर्ज करता है और केवल तभी शॉर्ट-सर्किट करता है जब सेल की मिस-रेट पर Wilson 95% ऊपरी-सीमा 5% या उससे कम हो जाती है।

यह जांचने के लिए कि आपके मॉडल किसमें अच्छे हैं, `/scorecard` का उपयोग करें (या सीधे: `libexec/raptor-llm-scorecard list`)। स्कोरकार्ड वैश्विक है (सीख प्रोजेक्ट्स में आगे बढ़ती है) और `out/llm_scorecard.json` पर बनी रहती है।

---

## प्रोजेक्ट्स

प्रोजेक्ट के बिना, प्रत्येक रन को `out/` के अंतर्गत अपनी स्वयं की टाइमस्टैम्प्ड निर्देशिका मिलती है। प्रोजेक्ट के साथ, सब कुछ एक ही स्थान पर जाता है और आपको विलय किए गए निष्कर्ष, कवरेज ट्रैकिंग, और रनों के बीच अंतर मिलते हैं।```bash
/project create myapp --target /path/to/code -d "Short description"
/project use myapp

/scan
/understand --map
/validate

/project status                # all runs, pass/fail, timestamps
/project findings              # merged findings across all runs
/project findings --detailed   # per-finding detail
/project coverage --detailed   # which files were reviewed
/project diff myapp run1 run2  # compare two runs
/project report                # full merged report
/project clean --keep 3        # remove old runs, keep the last 3
/project export myapp /tmp/myapp.zip
/project none                  # clear active project

विभाजन का मतलब है कि आप Python परत को CI पाइपलाइन से चला सकते हैं (`python3 raptor.py scan --repo ...`) और Claude Code के बिना संरचित SARIF आउटपुट प्राप्त कर सकते हैं, या इसे पूर्ण एजेंटिक वर्कफ़्लो के साथ इंटरैक्टिव रूप से चला सकते हैं।

---

## OSS फोरेंसिक्स

`/oss-forensics` कई स्रोतों से साक्ष्य का उपयोग करके सार्वजनिक GitHub रिपॉजिटरी की जांच करता है: GitHub API, GH Archive (BigQuery के माध्यम से अपरिवर्तनीय इवेंट इतिहास), Wayback Machine, और स्थानीय git इतिहास। यह साक्ष्य संग्रह से लेकर परिकल्पना निर्माण तक और अंतिम फोरेंसिक रिपोर्ट तक एक संरचित पाइपलाइन चलाता है।

BigQuery एक्सेस के लिए `GOOGLE_APPLICATION_CREDENTIALS` की आवश्यकता होती है। विवरण के लिए `.claude/commands/oss-forensics.md` देखें।

---

## विशेषज्ञ व्यक्तित्व

सात विशेषज्ञ व्यक्तित्व मांग पर उपलब्ध हैं। जब आप किसी निष्कर्ष या विशिष्ट तकनीक पर एक अलग दृष्टिकोण चाहते हैं तो एक को लोड करें:```
Exploit Developer (Mark Dowd)                  Exploit PoC generation
Crash Analyst (Charlie Miller / Halvar Flake)  Crash analysis and exploitability assessment
Security Researcher                            General adversarial code review
Patch Engineer                                 Secure fix generation
Penetration Tester                             Realistic attack scenario assessment
Fuzzing Strategist                             Corpus design and triage
Binary Exploitation Specialist                 ROP, heap, and memory corruption