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

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

लेखक: Gadi Evron, Daniel Cuthbert, Thomas Dullien (Halvar Flake), Michael Bargury, John Cartwright (@gadievron, @danielcuthbert, @thomasdullien, @mbrg, @grokjc)

लाइसेंस: MIT, LICENSE देखें। ध्यान दें कि CodeQL का अपना लाइसेंस है और यह व्यावसायिक उपयोग की अनुमति नहीं देता।

रिपॉज़िटरी: https://github.com/gadievron/raptor

RAPTOR क्या है?

RAPTOR एक स्वायत्त सुरक्षा अनुसंधान फ्रेमवर्क है जो Claude Code के ऊपर बनाया गया है (लेकिन इससे बंधा नहीं है -- आप अपनी स्वयं की विश्लेषण परत भी जोड़ सकते हैं)। यह स्टैटिक विश्लेषण, बाइनरी विश्लेषण, LLM-संचालित भेद्यता सत्यापन, एक्सप्लॉइट जनरेशन, और पैच लेखन को एक ही वर्कफ़्लो में जोड़ता है जिसे आप किसी कोडबेस या बाइनरी पर चला सकते हैं।

यह परिष्कृत सॉफ़्टवेयर नहीं है। इसे खाली समय में बनाया गया था, उत्साह और डक्ट टेप से जोड़कर रखा गया है, और यह इतना अच्छा काम करता है कि हम इसका उपयोग करना बंद नहीं कर पाते। यदि आप इसे बेहतर बनाना चाहते हैं, तो एक PR खोलें।

RAPTOR का अर्थ है Recursive Autonomous Penetration Testing and Observation Robot। हम वाकई इसे RAPTOR कहना चाहते थे।

यह कैसे बनाया गया है

RAPTOR ज़्यादातर AI-जनित कोड है। मनुष्य दिशा तय करते हैं, आउटपुट की समीक्षा करते हैं, और डिज़ाइन निर्णय लेते हैं; AI कार्यान्वयन लिखता है। यांत्रिक सत्यापन (टेस्ट, स्टैटिक विश्लेषण, कॉर्पस कैलिब्रेशन) गुणवत्ता मानक को वहीं बनाए रखता है जहाँ उसे होना चाहिए, चाहे कोड किसने — या क्या — लिखा हो।

पूर्वापेक्षाएँ

Claude Code एक सक्रिय सदस्यता (Max, Pro, Team, या Enterprise) या एक Anthropic API key के साथ। यह इंटरैक्टिव raptor शेल के लिए ऑर्केस्ट्रेशन परत है -- वैकल्पिक यदि आपको केवल स्टैंडअलोन CLI की आवश्यकता है, नीचे पूरी तरह से स्टैंडअलोन चलाना देखें।
Python 3.10+ और Node.js 18+।
Semgrep (pip install semgrep) स्टैटिक विश्लेषण के लिए। CodeQL वैकल्पिक है लेकिन अनुशंसित है।

विश्लेषण डिस्पैच परत के लिए (वह LLM जो व्यक्तिगत निष्कर्षों का विश्लेषण करता है), Claude Code स्वयं डिफ़ॉल्ट रूप से सब कुछ संभालता है -- किसी अतिरिक्त API key की आवश्यकता नहीं है। यदि आप मल्टी-मॉडल विश्लेषण (जैसे Claude + GPT + Gemini) या पूरी तरह से स्थानीय सेटअप चाहते हैं, तो आपको अन्य प्रोवाइडर को कॉन्फ़िगर करना होगा। नीचे एक अलग LLM का उपयोग करना देखें।

त्वरित शुरुआत

विकल्प 1: मैन्युअल रूप से इंस्टॉल करें```bash

Clone the repo

git clone https://github.com/gadievron/raptor.git cd raptor

Install Python dependencies

uv sync --locked

Compatibility path during the uv migration

pip install -r requirements.txt

Install Claude Code (if you don't already have it)

npm install -g @anthropic-ai/claude-code

Install Semgrep (required for scanning)

pip install semgrep

Add the launcher to your PATH -- put this in your shell profile to make it

permanent. Append rather than prepend, so system directories stay ahead of

the repo. (Alternatively, symlink bin/raptor into a directory already on PATH.)

export PATH="$PATH:$PWD/bin"

Launch RAPTOR

raptor

`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

या इसे शामिल Dockerfile का उपयोग करके स्थानीय रूप से बनाएं:```bash docker build -f .devcontainer/Dockerfile -t raptor:latest .

The image expects the RAPTOR framework (this repo) to be mounted into `/workspaces/raptor` on startup. You can optionally mount a target folder for local analysis.

To start the container:```bash
docker run -it \
  -v "$(pwd):/workspaces/raptor" \
  raptor:latest

लक्ष्य फ़ोल्डर को भी माउंट करने के लिए:```bash docker run -it
-v "$(pwd):/workspaces/raptor"
-v "/path/to/target-folder:/workspaces/target"
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"
]

फिर रेपो को VS Code में खोलें — यह आपको कंटेनर में फिर से खोलने के लिए प्रेरित करेगा:```bash cd /path/to/raptor code .

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

---

## पहली बार चलाने पर क्या अपेक्षा करें

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

यह लक्ष्य के विरुद्ध Semgrep (साथ ही Coccinelle जब spatch इंस्टॉल हो; CodeQL के लिए --codeql जोड़ें) चलाता है, निष्कर्षों को डुप्लिकेट-मुक्त करता है, और एक SARIF रिपोर्ट लिखता है। कोई LLM विश्लेषण नहीं, Claude Code के अलावा कोई API कुंजी नहीं। एक सामान्य रिपॉज़िटरी पर कुछ मिनट लगते हैं।

LLM-संचालित सत्यापन जोड़ने के लिए:``` /agentic /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 namespaces, 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` | मौजूदा SARIF फाइंडिंग्स का LLM के साथ विश्लेषण करें, बिना दोबारा स्कैन किए | स्थिर |
| `/openant` | OpenAnt LLM सोर्स-कोड स्कैन: AST एनालिसिस प्लस प्रति-फ़ंक्शन LLM रीज़निंग | बीटा |
| `/sca` | सॉफ़्टवेयर कंपोज़िशन एनालिसिस: डिपेंडेंसीज़, एडवाइज़रीज़, सप्लाई-चेन सिग्नल्स, SBOMs, और फिक्सेस | बीटा |
| `/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

संकलित आर्टिफैक्ट के लिए, समतुल्य प्रारंभिक बिंदु यह है:```text /binary investigate /path/to/binary # build the evidence-backed binary map /binary graph --edges --json # query the persisted graph /binary trace-parser # collect runtime parser evidence /binary harness # draft a harness only when the boundary is explicit

`/understand` स्कैनिंग शुरू होने से पहले entry points, trust boundaries, और sinks का context map बनाता है। फिर `/agentic` Semgrep और CodeQL चलाता है, findings को deduplicate करता है, और exploitation-validator methodology का उपयोग करके प्रत्येक को validation के लिए dispatch करता है:

`--threat-model` के साथ, RAPTOR पहले map चलाता है, यदि प्रोजेक्ट में पहले से मौजूद नहीं हैं तो `threat-model.json` और `THREAT_MODEL.md` बनाता है, फिर एक compact version को `/understand`, autonomous analysis, और `/validate` में feed करता है। मौजूदा project threat models तब तक संरक्षित रहते हैं जब तक आप `--threat-model-refresh` पास नहीं करते; stale fallback maps को अस्वीकार कर दिया जाता है जब तक आप स्पष्ट रूप से `--threat-model-use-stale` पास नहीं करते। यह mapped unchecked flows को candidate SARIF में भी बदल देता है ताकि scanner misses run को खत्म न करें। यह operator-owned context है, magic proof नहीं: findings को अभी भी code evidence या oracle-backed confirmation की आवश्यकता होती है। देखें `docs/threat-model.md`।

- Stage A: क्या pattern वास्तव में एक vulnerability है, या tool pattern-matching noise है?
- Stage B: इसे reach करने के लिए attacker को क्या चाहिए, और रास्ते में क्या आता है?
- Stage C: क्या code path वास्तव में मौजूद है? क्या इसे बाहर से reach किया जा सकता है?
- Stage D: final call -- क्या यह test code है, क्या इसे unrealistic preconditions चाहिए, क्या model hedging कर रहा है?
- Stage E: binary exploit feasibility (जब एक compiled artefact उपलब्ध हो)
- Stage F: self-review -- क्या किसी पिछले stage ने hedge किया या खुद से contradiction किया?

Validation पास करने वाले findings के लिए exploit PoCs और patches generate होते हैं। अंत में एक cross-finding analysis चलता है जो shared root causes और attack chains खोजता है।

`/validate` इसी pipeline को standalone step के रूप में चलाता है यदि आपके पास पहले के scan से findings पहले से हैं।

एक compiled artefact के लिए, `/binary <path>` अब operator पर raw reverse-engineering artefacts का ढेर डालने के बजाय evidence-first investigation चलाता है। नीचे यह अभी भी file metadata, imports और radare2 xrefs से SHA-256-bound manifest, evidence ledger, context map, checklist और SQLite graph बनाता है। Mach-O apps को slice inventory, bundle metadata और Objective-C / Swift class selectors भी मिलते हैं; high-value pseudocode persist किया जाता है बजाय run के अंदर गायब होने के। PE DLL exports, Windows driver dispatchers और Linux kernel-module ioctl handlers को भी उनके अपने ingress candidates के रूप में handle किया जाता है, PE architecture COFF header से पढ़ा जाता है अनुमान लगाने के बजाय। Investigation layer फिर उस graph को query करता है, generic sink leads से पहले external ingress को rank करता है, declared helper/sibling binaries खोजता है, और एक compact report लिखता है जो facts, structural inferences और unproven hypotheses में विभाजित होती है। Frida observations, fuzz crash witnesses, explicit Z3 checks और binary diffs बाद में मजबूत evidence जोड़ सकते हैं। RAPTOR bounded ingress-to-parser candidates recover करने के लिए आवश्यक internal call graph भी रखता है, ताकि एक app callback को उस internal function तक narrow किया जा सके जो वास्तव में `XML_Parse`, `d2i_X509`, `jpeg_read_header` या किसी अन्य real parser surface को call करता है, बिना यह दिखावा किए कि यह taint proof है। `/binary trace-parser <run-dir>` स्पष्ट dynamic follow-on है: यह narrow Frida parser trace चलाता है, फिर उसी context map, handoff, graph और investigation report को in place refresh करता है। `/binary investigate --active` पहले map करता है और केवल तब real fuzz campaign launch करता है जब एक concrete harness boundary मौजूद हो; app, DLL और driver targets को इसके बजाय harness या snapshot step मिलता है। `/binary harness` चुने गए ingress के लिए evidence-backed harness spec लिखता है और candidate source केवल तब emit करता है जब ABI या IOCTL contract स्पष्ट हो। यह "`memcpy` मौजूद है" से "यह exploitable है" तक बहाने से नहीं पहुँचता: imports, selectors और call edges candidates रहते हैं जब तक कोई mechanical चीज़ अधिक साबित न करे। देखें `docs/binary-analysis.md`।

---

## Software Composition Analysis

`/sca` किसी प्रोजेक्ट के dependency और supply-chain पक्ष का विश्लेषण करता है। यह केवल requirements-file CVE lookup नहीं है: RAPTOR manifests, lockfiles, inline install commands, workflow dependencies, और container/base-image package sources खोजता है, फिर उन्हें एक single dependency view में normalise करता है।

Scan dependencies को OSV advisories, CISA KEV, EPSS, CISA Vulnrichment/SSVC, reachability, exploit-evidence signals, hygiene checks, supply-chain heuristics, licence policy findings, और optional LLM review/triage से enrich करता है। यह RAPTOR-native findings के साथ-साथ SBOM और CI-friendly output emit करता है:

- `findings.json` - canonical RAPTOR findings
- `report.md` - human-readable summary
- `sbom.cdx.json` - CycloneDX SBOM with VEX data
- `findings.sarif` - GitHub/GitLab code-scanning output

Common commands:```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

उपयोगी सबकमांड्स में fix, check, upgrade, diff, verify, health, render, suppress, और clean-cache शामिल हैं। पूर्ण संदर्भ के लिए docs/sca.md देखें।

Z3 SMT एकीकरण

RAPTOR में दो-स्तरीय Z3 एकीकरण है (pip install z3-solver)। यह वैकल्पिक है। इसके बिना सब कुछ काम करता है, लेकिन इसके साथ परिणाम बेहतर होते हैं।

डेटाफ़्लो प्री-स्क्रीनिंग (CodeQL)

जब CodeQL एक पथ परिणाम उत्पन्न करता है, तो किसी भी LLM कॉल से पहले पथ बाधाओं की संतुष्टि-योग्यता की जाँच की जाती है। जो पथ सिद्ध रूप से अगम्य हैं, उन्हें तुरंत हटा दिया जाता है। जो पथ पहुँच-योग्य हैं, उनके लिए Z3 ठोस उम्मीदवार इनपुट उत्पन्न करता है जो विश्लेषण प्रॉम्प्ट में जाते हैं, ताकि LLM के पास अमूर्त पैटर्न के बजाय तर्क करने के लिए कुछ ठोस हो।

वन-गैजेट बाधा विश्लेषण (बाइनरी व्यवहार्यता)

बाइनरी एक्सप्लॉइट व्यवहार्यता मूल्यांकन के दौरान, Z3 जाँचता है कि क्या किसी वन-गैजेट की रजिस्टर और मेमोरी बाधाएँ ठोस क्रैश स्थिति के विरुद्ध संतुष्टि-योग्य हैं। गैजेट्स को अनुमानी तरीकों के बजाय वास्तविक पहुँच-योग्यता के आधार पर रैंक किया जाता है, ताकि आप उन गैजेट्स पर समय व्यतीत करें जो वास्तव में काम कर सकते हैं।

Z3 devcontainer में पहले से इंस्टॉल है। मैन्युअल इंस्टॉल के लिए: pip install z3-solver।

ऑफ़लाइन और एयर-गैप्ड पाइपलाइनों में चलाना

engine/semgrep/rules/ के अंतर्गत RAPTOR के कस्टम नियम पूरी तरह से स्थानीय हैं और नेटवर्क एक्सेस के बिना चलते हैं।

रजिस्ट्री पैक्स (p/security-audit, p/owasp-top-ten, आदि) के लिए, कैश डायरेक्टरी खाली भेजी जाती है। एक कैश टूल (engine/semgrep/tools/cache-packs.py) पॉप्युलेशन को संभालता है:```bash

On a connected machine — update the local cache directly:

python3 engine/semgrep/tools/cache-packs.py update

Or fetch into a zip bundle for airgap transfer:

python3 engine/semgrep/tools/cache-packs.py fetch

→ produces semgrep-cache-YYYY-MM-DD.zip

On the airgapped machine — import the bundle:

python3 engine/semgrep/tools/cache-packs.py import semgrep-cache-2026-07-16.zip

Check what's cached:

python3 engine/semgrep/tools/cache-packs.py list

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

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

---

## Custom rules

RAPTOR में 200 से अधिक custom static analysis rules शामिल हैं, जिन्हें false positives को खत्म करने के लिए adversarially tested किया गया है:

- **Semgrep (~150 rules)** — Python, Go, Java, और JS/TS के लिए taint-tracking और pattern rules। SQLi, XSS, SSRF, SSTI, command injection, deserialisation, XXE, LDAP/NoSQL injection, path traversal, open redirect, log/header injection, eval injection, ReDoS, prototype pollution, JWT misconfiguration, weak crypto, insecure TLS, और hardcoded secrets को कवर करता है।
- **Coccinelle (68 rules)** — C/C++ के लिए structural matching। Memory safety (double free, use-after-free, free of non-base pointer, free of stack array, mmap'd memory, use-after-close), integer bugs (overflow, sign extension, double sizeof), resource leaks (popen/fclose mismatch, fdopendir double close), buffer handling (strncpy without NUL, copy_user size mismatch, malloc/strlen off-by-one), signal handler safety, API misuse (fcntl flag domain, SIGKILL/SIGSTOP, double byte-swap, inet_ntoa static buffer), compiler dead-store elimination, kernel IS_ERR/PTR_ERR confusion, format string injection, TOCTOU races, और बहुत कुछ।
- **CodeQL (8 queries)** — C++ (format string injection, integer truncation, use-after-move, iterator invalidation) और Java (XXE, insecure deserialisation, log injection, Spring SSRF) के लिए interprocedural taint tracking।

सीधे rules ब्राउज़ करें: `engine/semgrep/rules/`, `engine/coccinelle/rules/`, `engine/codeql/queries/`। ये उन Semgrep registry packs की पूरक हैं जिन्हें RAPTOR खींचता है (`p/security-audit`, `p/owasp-top-ten`, `p/secrets` हमेशा; ऊपर से per-policy-group packs जैसे `p/command-injection`, `p/jwt`, `p/xss`) — overlap न्यूनतम है।

---

## RAPTOR स्वयं को कैसे जाँचता है

RAPTOR अपने स्वयं के सुरक्षा tooling का काफ़ी उपयोग करता है, लेकिन इस बारे में ईमानदार रहना उचित है कि वास्तव में क्या PR को रोकता है और क्या केवल पृष्ठभूमि में चलता है ताकि हम ईमानदार बने रहें। इसमें से कुछ एक hard gate है, कुछ एक scheduled check है, और कुछ केवल एक benchmark है जिसे हम इसलिए रखते हैं ताकि हम बता सकें कि हमने चीज़ों को और खराब कब कर दिया है। अधिक विस्तृत विवरण, जिसमें वास्तविक parameters और checks को reproduce करने का तरीका शामिल है, `docs/ci-controls.md` में है।

| Control | What it checks | Trigger | Config / evidence |
|---|---|---|---|
| Ruff | Python correctness linting (`F401`, `F811`, `F821`, `F841`) | PR diff gate, plus weekly full-tree audit | `pyproject.toml`, `.github/workflows/lint.yml` |
| Pytest | Fast unit/integration boundaries, subsystem-specific tiers (via import-graph dispatch), prompt-envelope audit | PRs, pushes to `main`, merge queue, scheduled full suite | `pytest.ini`, `.github/workflows/tests.yml`, `.github/workflows/nightly.yml` |
| CodeQL Advanced | Python, C/C++, and GitHub Actions code scanning with import-graph scope narrowing | PRs, pushes to `main`, merge queue, weekly schedule | `.github/workflows/codeql.yml`, `.github/codeql/codeql-config.yml` |
| Workflow hardening | SHA-pinned third-party Actions, least-privilege permissions, command metadata linting | Every workflow change and every lint run | `.github/workflows/`, `.github/scripts/check_command_metadata.py` |
| Corpus label lint | Audit corpus label schema validation and upstream pin verification | PRs (changed labels), weekly full sweep | `.github/workflows/corpus-labels.yml` |
| RAPTOR SCA PR gate | Dependency and supply-chain regressions introduced by a PR | Manifest / lockfile / workflow changes | `.github/workflows/sca-pr-gate.yml` |
| RAPTOR SCA self-bump | Mechanical dependency hardening and safe upgrade proposals | Weekly schedule, manual run | `.github/workflows/sca-self-bump.yml` |
| SCA compromise corpus | Whether known dependency compromises still trigger the expected signal | Weekly schedule, relevant PR changes | `test/data/sca-e2e/compromise-corpus/`, `.github/workflows/sca-compromise-check.yml` |
| Repo-invariant detectors | Dead-code / wrong-call detection, env-var documentation drift, vocabulary-list guardrails, canonical-JSON byte forms, optional-dep import lint | PR gate (`lint.yml` `repo-invariants` job), plus daily sweep | `.github/workflows/lint.yml`, `.github/workflows/miswiring-scan.yml`, `.github/scripts/*_baseline.json` |
| SCA calibration + stress corpus | Whether risk scoring and parser coverage drift over time | Weekly / monthly scheduled jobs | `packages/sca/data/calibration/`, `.github/workflows/refresh-sca-calibration.yml`, `.github/workflows/sca-stress-sweep.yml` |
| Dataflow corpus | Precision / recall / FP-category tracking for validator behaviour | Developer-run benchmark and corpus tests | `core/dataflow/corpus/`, `core/dataflow/scripts/corpus-metrics` |
| CI controls doc guard | Documented paths exist, ruff config matches, README links to the doc | PRs | `.github/tests/test_ci_controls_docs.py` |

वर्तमान में लागू नहीं: `mypy` `pyproject.toml` में pinned है लेकिन किसी चीज़ को block नहीं करता; Ruff formatting लागू नहीं है; Semgrep RAPTOR की scanner surface का हिस्सा है, लेकिन हमारे पास अभी तक एक समर्पित "scan RAPTOR with RAPTOR" Semgrep workflow नहीं है।

---

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

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

**orchestration layer** Claude Code है -- लेकिन केवल interactive `raptor` shell के लिए (यह conversational, slash-command layer)। CLAUDE.md, skills, और commands सभी वहाँ Claude Code instructions के रूप में चलते हैं। उस layer को orchestrate करने वाले Claude model को बदलने के लिए, Claude Code के `--model` flag या session के अंदर `/model` command का उपयोग करें। यदि आप यह layer बिल्कुल नहीं चाहते हैं, तो नीचे [Running fully standalone](#running-fully-standalone-no-claude-code) देखें।

**analysis dispatch layer** वह LLM है जो व्यक्तिगत vulnerability findings का विश्लेषण करता है। यह orchestration layer से अलग है और कोई भी supported provider हो सकता है। इसे `~/.config/raptor/models.json` में configure करें:```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"
    }
  ]
}

या कॉन्फ़िग फ़ाइल को छोड़ें और environment variables सेट करें। RAPTOR उन्हें स्वतः पहचान लेगा:```bash export ANTHROPIC_API_KEY=sk-ant-... # Anthropic Claude export OPENAI_API_KEY=sk-... # OpenAI export GEMINI_API_KEY=... # Google Gemini export MISTRAL_API_KEY=... # Mistral export OLLAMA_HOST=http://localhost:11434 # Local Ollama

मॉडल भूमिकाएँ आपको विभिन्न कार्यों के लिए अलग-अलग मॉडल असाइन करने देती हैं:

| भूमिका | यह क्या करती है |
|------|-------------|
| `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

बजट नियंत्रण:```bash

Cap analysis-layer LLM spend at $5 for this run (default: $10)

python3 raptor.py agentic --repo /code --max-cost-usd 5.00

Ollama विश्लेषण के लिए अच्छी तरह काम करता है; exploit/patch कोड जनरेशन के लिए विश्वसनीयता मॉडल स्केल और क्वांटाइज़ेशन पर निर्भर करती है, न कि स्थानीय मॉडलों का एक निश्चित गुण होने पर — LLM गाइड में [Quality Tradeoffs](https://github.com/gadievron/raptor/blob/main/llm.md#quality-tradeoffs) देखें, और जाँचें कि आपका विशिष्ट मॉडल वास्तव में क्या माप रहा है, इसके लिए `/scorecard` देखें।

### पूरी तरह से स्टैंडअलोन चलाना (Claude Code के बिना)

`bin/raptor` -- बैनर और स्लैश कमांड वाला इंटरैक्टिव शेल, यानी यह संवादात्मक परत -- सीधे Claude Code CLI में exec करता है और हमेशा अपने स्वयं के लॉगिन की आवश्यकता होती है। इसके नीचे की वास्तविक कार्यप्रणाली को इसकी आवश्यकता नहीं है: `python3 raptor.py <mode>` एक सादा Python CLI है जिसमें Claude Code पर कोई निर्भरता नहीं है।```bash
# No `claude` process involved at any point
python3 raptor.py doctor                        # status check -- explicitly "no claude needed"
python3 raptor.py agentic --repo /path/to/code   # scan -> dedup -> analysis
python3 raptor.py scan --repo /path/to/code

libexec/raptor-* स्क्रिप्ट्स (जिनमें raptor-project-manager भी शामिल है -- raptor.py में project मोड नहीं है, प्रोजेक्ट प्रबंधन विशेष रूप से वहीं रहता है) भी सादा Python हैं, लेकिन वे तब तक चलने से इनकार कर देती हैं जब तक CLAUDECODE सेट न हो (Claude Code सत्र के अंदर स्वतः true हो जाता है) या _RAPTOR_TRUSTED=1 स्पष्ट रूप से सेट न हो -- यह लॉन्चर के environment sanitisation के बाहर invoke होने से बचाव है। स्टैंडअलोन उपयोग के लिए इसे एक बार सेट करें:```bash export _RAPTOR_TRUSTED=1

libexec/raptor-project-manager create myapp --target /path/to/code libexec/raptor-project-manager use myapp python3 raptor.py agentic --repo /path/to/code # picks up the active project automatically libexec/raptor-project-manager status libexec/raptor-project-manager findings

`models.json` / `OLLAMA_HOST` को लोकल Ollama इंस्टेंस की ओर पॉइंट करें (ऊपर देखें) और यह पूरा पाथ कभी भी Anthropic से बात नहीं करता -- airgapped बॉक्स या केवल-लोकल हार्डवेयर के लिए उपयोगी। आप संवादात्मक slash-command लेयर (यह चैट) खो देते हैं; scan/analysis/exploit पाइपलाइन स्वयं अप्रभावित रहती है।

### Fast-tier short-circuit + मॉडल स्कोरकार्ड

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

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

---

## Projects

प्रोजेक्ट के बिना, प्रत्येक रन को `out/` के अंतर्गत अपनी टाइमस्टैम्प वाली डायरेक्टरी मिलती है। प्रोजेक्ट के साथ, सब कुछ एक ही जगह जाता है और आपको merged findings, coverage tracking, और रन्स के बीच diffs मिलते हैं।```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

आर्किटेक्चर

RAPTOR दो परतों में है।

Python execution layer (raptor.py, packages/, core/, engine/) भारी काम संभालती है: Semgrep और CodeQL चलाना, subprocesses प्रबंधित करना, SARIF पार्स करना, findings को deduplicate करना, LLM API calls भेजना, लागत ट्रैक करना, output files लिखना। यह निर्णय नहीं लेती। यह निष्पादित करती है।

Claude Code decision layer (.claude/, tiers/, CLAUDE.md) निर्णय लेती है: किन findings को प्राथमिकता देनी है, परिणामों की व्याख्या कैसे करनी है, attack scenario क्या है, exploit वास्तविक है या नहीं। Claude Code skills, commands, और agents के रूप में कार्यान्वित, जो क्रमशः लोड होते हैं।``` CLAUDE.md always loaded -- bootstrap, routing, security rules .claude/commands/ slash commands (/agentic, /scan, /validate, etc.) .claude/skills/ methodology detail, loaded on demand tiers/ adversarial thinking, recovery, expert personas .claude/agents/ specialist sub-agents (offsec, crash analysis, forensics)

The split means you can run the Python layer from a CI pipeline (`python3 raptor.py scan --repo ...`) and get structured SARIF output without Claude Code, or run it interactively with the full agentic workflow.

---

## OSS forensics

`/oss-forensics` investigates public GitHub repositories using evidence from multiple sources: the GitHub API, GH Archive (immutable event history via BigQuery), the Wayback Machine, and local git history. It runs a structured pipeline from evidence collection through hypothesis formation to a final forensic report.

Requires `GOOGLE_APPLICATION_CREDENTIALS` for BigQuery access. See `.claude/commands/oss-forensics.md` for details.

---

## Expert personas

Eight expert personas are available on demand. Load one when you want a different perspective on a finding or a specific technique:```
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
Web Researcher (James Kettle)                  Web endpoint research (smuggling, cache poisoning, SSRF)
Fuzzing Strategist                             Corpus design and triage
Binary Exploitation Specialist                 ROP, heap, and memory corruption

Claude को बताएं कि किसका उपयोग करना है, उदा. "Use the Binary Exploitation Specialist"।

Documentation

पूरी सूची के लिए docs/README.md देखें। मुख्य गाइड:

File	Contents
`docs/commands.md`	हर flag के साथ पूर्ण slash-command संदर्भ
`docs/architecture.md`	कोडबेस संरचना और directory tree
`docs/llm.md`	LLM provider कॉन्फ़िगरेशन, Bedrock, multi-model workflows
`docs/sandbox.md`	Process isolation: profiles, Landlock, namespaces
`docs/troubleshooting.md`	Self-test, sandbox setup त्रुटियाँ (Ubuntu 24.04+ पर mount-ns/uidmap), EDR interaction
`docs/agent-security.md`	Agent क्षमताएँ, tool boundaries, network controls, human approval
`docs/audit.md`	व्यवस्थित कोड समीक्षा: hypotheses, tools, strategies, gates
`docs/validation.md`	Exploitability validation pipeline (चरण 0--1)
`docs/static-analysis.md`	Semgrep और Coccinelle नियम
`docs/codeql.md`	CodeQL एकीकरण और स्वायत्त विश्लेषण
`docs/binary-analysis.md`	Binary oracle, `/binary`, exploit feasibility
`docs/fuzzing.md`	AFL++ और libFuzzer
`docs/crash-analysis.md`	स्वायत्त crash root-cause विश्लेषण
`docs/sca.md`	Software composition analysis
`docs/frida.md`	Dynamic instrumentation
`docs/security.md`	RAPTOR का अपना सुरक्षा मॉडल
`docs/ci-controls.md`	CI controls, workflows, और benchmark साक्ष्य
`docs/threat-model.md`	प्रति-प्रोजेक्ट threat model सुविधा
`docs/python-cli.md`	स्क्रिप्टिंग और CI के लिए Python CLI संदर्भ
`docs/concepts.md`	मुख्य अवधारणाएँ: two-layer model, finding lifecycle, कमांड चुनना
`docs/agentic.md`	स्वायत्त workflow: `/agentic` pipeline, enrichment flags, multi-model
`docs/sage.md`	SAGE स्थायी मेमोरी: setup, HMAC key, CPU/GPU, उपयोग के मामले
`docs/dependencies.md`	बाहरी tools, संस्करण, और licences
`tiers/personas/README.md`	Expert persona संदर्भ

Contributing

RAPTOR ओपन सोर्स है। यदि आप योगदान देना चाहते हैं तो शुरू करने के लिए अच्छी जगहें:

web scanner के लिए browser-engine crawling और DOM XSS coverage (Playwright pinned है लेकिन अप्रयुक्त)
annotation-driven frameworks के लिए SSRF rule coverage (Spring @RequestParam, FastAPI typed params) — semgrep इन sources को match नहीं कर सकता, इसलिए वैकल्पिक दृष्टिकोण स्वागत योग्य हैं
YARA signature generation
अन्य AI coding tools (Cursor, Windsurf, Copilot, Cline) के लिए ports
बेहतर firmware analysis coverage
जो भी आपको छूटा हुआ लगे

Releases को vX.Y.Z के रूप में tag किया जाता है और CI द्वारा स्वचालित रूप से build किया जाता है। Commit prefixes यह निर्धारित करते हैं कि changelog में क्या जाएगा: नई सुविधाओं के लिए feat:, bug fixes के लिए fix:, security परिवर्तनों के लिए security:, documentation के लिए docs:। बिना prefix वाला कुछ भी "Other changes" में जाता है। कोई सख्त convention आवश्यक नहीं, लेकिन यह मदद करता है।

Pull requests सबमिट करें। Prompt||GTFO Slack में #raptor channel पर हमसे चैट करें: https://join.slack.com/t/promptgtfo/shared_invite/zt-3v2b4sll3-SfyzFRw2lykx_XQX7F3uNQ

Licence

पूरा पाठ LICENSE में देखें। व्यावसायिक उपयोग से पहले सभी dependencies के licences की समीक्षा करें -- विशेष रूप से CodeQL इसे अनुमति नहीं देता।

Issues: https://github.com/gadievron/raptor/issues

Python Dependencies

RAPTOR Python dependencies के लिए pyproject.toml और uv.lock को source of truth के रूप में उपयोग करता है। Checked-in requirements.txt उन उपयोगकर्ताओं के लिए compatibility export के रूप में बना हुआ है जो pip install पसंद करते हैं।

उपयोगी installs:```bash uv sync --locked # core runtime uv sync --locked --group dev # tests + linting uv sync --locked --extra web # /web scanner support uv sync --locked --extra "web smt llm sage" # optional stacks

`/web`, Z3, SAGE और क्लाउड प्रोवाइडर SDKs को वैकल्पिक अतिरिक्त के रूप में रखने से डिफ़ॉल्ट RAPTOR इंस्टॉल को आवश्यकता से अधिक भारी और नाजुक बनने से बचा जाता है।

raptor v3.1.0

श्रेणियाँ