╔═══════════════════════════════════════════════════════════════════════════╗
║                                                                           ║
║             ██████╗  █████╗ ██████╗ ████████╗ ██████╗ ██████╗             ║
║             ██╔══██╗██╔══██╗██╔══██╗╚══██╔══╝██╔═══██╗██╔══██╗            ║
║             ██████╔╝███████║██████╔╝   ██║   ██║   ██║██████╔╝            ║
║             ██╔══██╗██╔══██║██╔═══╝    ██║   ██║   ██║██╔══██╗            ║
║             ██║  ██║██║  ██║██║        ██║   ╚██████╔╝██║  ██║            ║
║             ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝        ╚═╝    ╚═════╝ ╚═╝  ╚═╝            ║
║                                                                           ║
║             Autonomous Offensive/Defensive Research Framework             ║
║             Based on Claude Code (v3.0.0)                                 ║
║                                                                           ║
║             Gadi Evron, Daniel Cuthbert, Thomas Dullien (Halvar Flake)    ║
║             Michael Bargury, John Cartwright                              ║
║                                                                           ║
╚═══════════════════════════════════════════════════════════════════════════╝

⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⣤⣤⣀⣀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⣿⣿⠿⠿⠟
⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣀⣀⣀⣀⣀⣤⣴⣶⣶⣶⣤⣿⡿⠁⠀⠀⠀
⣀⠤⠴⠒⠒⠛⠛⠛⠛⠛⠿⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠁⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠛⣿⣿⣿⡟⠻⢿⡀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⢿⣿⠟⠀⠸⣊⡽⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⣿⡁⠀⠀⠀⠉⠁⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⠿⣿⣧⠀ Get them bugs.....⠀⠀⠀⠀⠀

यदि आप `bin/` को अपने PATH में जोड़ते हैं (या `bin/raptor` को PATH पर कहीं symlink करते हैं), तो आप किसी भी निर्देशिका से `raptor` चला सकते हैं — लांचर RAPTOR इंस्टॉलेशन को हल करता है और स्वचालित रूप से कार्यशील निर्देशिका सेट करता है।

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

### विकल्प 2: Devcontainer (अनुशंसित)

सब कुछ पूर्व-स्थापित। VS Code में **Dev Containers: Open Folder in Container** के साथ खोलें, या पूर्व-निर्मित इमेज खींचें:```bash
docker pull danielcuthbert/raptor:latest
docker run --privileged -it -v "$(pwd):/workspaces/raptor" danielcuthbert/raptor:latest

The `--privileged` फ़्लैग `rr` निर्धारक डीबगर के लिए आवश्यक है। यह इमेज बड़ी है (लगभग 6 GB)। यह Microsoft Python 3.12 डेवकंटेनर से शुरू होता है और static analysis, fuzzing, और browser automation tooling जोड़ता है।

एक बार अंदर जाने पर, शुरू करने के लिए बस "hi" कहें, या सीधे किसी कमांड पर जाएँ।

---

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

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

यह पूर्ण पाइपलाइन चलाता है: स्कैन करें, डुप्लिकेट हटाएं, फिर प्रत्येक खोज को सत्यापन चरणों (A-F) के माध्यम से भेजें। लगभग ~50 खोजों वाले मध्यम आकार के कोडबेस पर, विश्लेषण-स्तर LLM लागत में 10-30 मिनट और $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` | ब्लैक-बॉक्स बाइनरी जांच, रनटाइम साक्ष्य, ग्राफ़ क्वेरी और हैंडऑफ़ | बीटा |
| `/validate` | बहु-चरण शोषण-क्षमता सत्यापन पाइपलाइन (चरण 0-F) | स्थिर |
| `/codeql` | SMT डेटाफ़्लो प्री-स्क्रीनिंग के साथ केवल CodeQL गहन विश्लेषण | स्थिर |
| `/sca` | सॉफ़्टवेयर संरचना विश्लेषण: निर्भरताएँ, सलाह, आपूर्ति-श्रृंखला संकेत, SBOM, और सुधार | बीटा |
| `/exploit` | प्रूफ-ऑफ-कॉन्सेप्ट शोषण कोड उत्पन्न करें | बीटा |
| `/patch` | पुष्टि की गई भेद्यताओं के लिए सुरक्षित पैच उत्पन्न करें | बीटा |
| `/fuzz` | AFL++ के साथ बाइनरी फ़ज़िंग और क्रैश विश्लेषण | स्थिर |
| `/crash-analysis` | C/C++ क्रैश के लिए स्वायत्त मूल-कारण विश्लेषण | स्थिर |
| `/oss-forensics` | GitHub रिपॉजिटरी के लिए साक्ष्य-समर्थित फोरेंसिक जांच | स्थिर |
| `/project` | रन व्यवस्थित करने और समय के साथ निष्कर्षों को ट्रैक करने के लिए नामित वर्कस्पेस | स्थिर |
| `/threat-model` | प्रति-प्रोजेक्ट खतरा मॉडल बनाएं, निरीक्षण करें और बनाए रखें | स्थिर |
| `/sage` | स्थायी मेमोरी परत (स्टोर करें, याद करें, लिंक करें, पुष्टि करें) | स्थिर |
| `/frida` | Frida के माध्यम से गतिशील इंस्ट्रुमेंटेशन | अल्फा |
| `/web` | वेब एप्लिकेशन स्कैनिंग | अल्फ़ा/स्टब |

---

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

एक प्रोजेक्ट बनाकर शुरू करें ताकि आपके सभी रन एक ही स्थान पर आएं:```
/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`।

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

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

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

एक संकलित कलाकृति के लिए, `/binary <path>` अब ऑपरेटर पर कच्चे रिवर्स-इंजीनियरिंग कलाकृतियों का ढेर डालने के बजाय एक साक्ष्य-प्रथम जांच चलाता है। इसके नीचे यह अभी भी फ़ाइल मेटाडेटा, आयात और radare2 xrefs से SHA-256-बद्ध मेनिफेस्ट, साक्ष्य बहीखाता, संदर्भ मानचित्र, चेकलिस्ट और SQLite ग्राफ बनाता है। Mach-O ऐप्स को स्लाइस इन्वेंट्री, बंडल मेटाडेटा और Objective-C / Swift क्लास सेलेक्टर भी मिलते हैं; उच्च-मूल्य वाले स्यूडोकोड को रन के अंदर गायब होने के बजाय संग्रहीत किया जाता है। PE DLL एक्सपोर्ट, विंडोज ड्राइवर डिस्पैचर्स और लिनक्स कर्नेल-मॉड्यूल 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` एक परियोजना के निर्भरता और आपूर्ति-श्रृंखला पक्ष का विश्लेषण करता है। यह केवल एक आवश्यकता-फ़ाइल 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

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

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

---

## कस्टम नियम

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

- **Semgrep (123 नियम)** — Python, Go, Java, और JS/TS के लिए टेंट-ट्रैकिंग और पैटर्न नियम। इसमें SQLi, XSS, SSRF, SSTI, कमांड इंजेक्शन, डिसीरियलाइज़ेशन, XXE, LDAP/NoSQL इंजेक्शन, पथ ट्रैवर्सल, ओपन रिडायरेक्ट, लॉग/हैडर इंजेक्शन, eval इंजेक्शन, ReDoS, प्रोटोटाइप प्रदूषण, JWT गलत कॉन्फ़िगरेशन, कमज़ोर क्रिप्टो, असुरक्षित TLS, और हार्डकोडेड सीक्रेट्स शामिल हैं।
- **Coccinelle (54 नियम)** — C/C++ के लिए संरचनात्मक मिलान। मेमोरी सुरक्षा (डबल फ्री, यूज़-आफ्टर-फ्री, गैर-बेस पॉइंटर का फ्री, स्टैक एरे का फ्री, mmap'd मेमोरी, यूज़-आफ्टर-क्लोज़), इंटीजर बग्स (ओवरफ़्लो, साइन एक्सटेंशन, डबल 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/`। ये रजिस्ट्री पैक्स (`p/security-audit`, `p/owasp-top-ten`, `p/0xdea`, `p/trailofbits`) के पूरक हैं जो लगभग 950 अतिरिक्त नियम प्रदान करते हैं — ओवरलैप न्यूनतम है।

---

## भिन्न 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 सस्ते और पूर्ण के बीच सहमति दर्ज करता है और केवल तब शॉर्ट-सर्किट करता है जब सेल की मिस-दर पर विल्सन 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

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

---

## OSS forensics

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

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

---

## Expert personas

सात expert personas ऑन डिमांड उपलब्ध हैं। जब आप किसी निष्कर्ष या विशिष्ट तकनीक पर अलग दृष्टिकोण चाहते हैं, तो एक को लोड करें:```
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