नेल्सन

मूर्खतापूर्ण ब्रूट फोर्स के माध्यम से कमजोरियाँ ढूँढना

Nicholas Carlini के एक टॉक और Ralph loop से प्रेरित होकर, Nelson एक उपकरण है जो किसी प्रोजेक्ट की हर फ़ाइल पर लूप करता है, एक एजेंट को कमजोरियाँ खोजने के लिए प्रेरित करता है। इसमें एक स्कैन मोड है, जो Carlini के bash loop के समान है, जहाँ यह मॉडल से किसी फ़ाइल या फ़ाइलों के निर्देशिका में कोई भी कमजोरी खोजने के लिए कहता है; एक समीक्षा मोड, जहाँ एक (आमतौर पर अधिक स्मार्ट) मॉडल प्रत्येक रिपोर्ट की गई कमजोरी की फिर से जाँच करता है और यह तय करता है कि क्या इसे मानव समीक्षक के पास भेजना उचित है; और बीच में एक डी-डुप्लीकेशन चरण, ताकि कई बार मिली एक ही बग का केवल एक बार मूल्यांकन हो।

व्यापक बेंचमार्किंग से बड़ा सबक यह है कि पुनरावृत्ति ही बग को सामने लाती है। पिछले संस्करणों में एक "फोकस्ड मोड" था जो मॉडल से एक बार में एक विशिष्ट CWE वर्ग का शिकार करने के लिए कहता था, और ऐसा लगता था कि इससे मदद मिली — लेकिन वह एक भ्रम था: प्रति-CWE विस्तार ने मॉडल को प्रत्येक फ़ाइल को कई बार देखने पर मजबूर किया, और यह पुनरावृत्ति थी, न कि CWE लक्ष्यीकरण, जो काम कर रही थी। बग वर्ग का नामकरण, चेकलिस्ट और अन्य प्रॉम्प्ट-शेपिंग ने नियंत्रित A/B परीक्षणों में कोई वास्तविक सुधार नहीं दिया। इसलिए फोकस्ड मोड हटा दिया गया है। इसके बजाय, --repeat N पूरे फ़ाइल × मॉडल मैट्रिक्स को N बार (डिफ़ॉल्ट 3) चलाता है, जो समान टोकन का कहीं बेहतर उपयोग है। पहचान वास्तव में अविश्वसनीय है — एक ढूंढने योग्य बग अक्सर तीन पास में से केवल एक में दिखाई देता है — इसलिए एक ही मॉडल के साथ भी दोहराना अब मानक अभ्यास है।

अधिक रिपोर्ट की गई समस्याएं आवश्यक रूप से अच्छी बात नहीं हैं यदि अधिक झूठी सकारात्मकताएं हों (और छोटे मॉडलों के साथ वे होती हैं)। पुनरावृत्ति इसे अपने आप और खराब कर देती है — एक ही बग हर पास पर फिर से प्रकट होता है — इसलिए Nelson निष्कर्षों को समीक्षा से पहले क्लस्टर (एक ही फ़ाइल/CWE कुछ पंक्तियों के भीतर) में डी-डुप्लीकेट करता है: प्रत्येक अद्वितीय बग का एक बार मूल्यांकन किया जाता है और निर्णय प्रत्येक प्रति पर लागू होता है। यह (अक्सर महंगे) समीक्षा मॉडल को एक ही निष्कर्ष की बार-बार पुष्टि करने के लिए भुगतान करने से बचाता है। अगर यह एक बार वास्तविक बग है, तो दूसरी बार भी यह वास्तविक बग है। समीक्षा के लिए एक स्मार्ट मॉडल का उपयोग करना एक अच्छा विचार है, लेकिन एक बेवकूफ मॉडल भी समीक्षा में अपनी गलतियों को पकड़ सकता है।

Nelson Claude Code, Gemini CLI, और OpenAI संगत APIs के माध्यम से विभिन्न मॉडलों के साथ काम करता है। एक ही मॉडल के भीतर, कार्य एक-एक करके चलते हैं — सब्सक्रिप्शन प्लान में रोलिंग टोकन सीमाएं होती हैं और स्थानीय मॉडल अपेक्षाकृत मामूली हार्डवेयर पर चलते हैं, इसलिए एक प्रदाता पर अतिरिक्त समवर्तीता से कोई लाभ नहीं है। हालांकि, विभिन्न मॉडलों के बीच, दर सीमाएं स्वतंत्र होती हैं, इसलिए जब आप कई -m विशिष्टताएं पास करते हैं, तो Nelson डिफ़ॉल्ट रूप से प्रति मॉडल एक वर्कर को समानांतर में चलाता है (उदा., Claude, Gemini, और LM Studio के माध्यम से एक स्थानीय Qwen सभी एक साथ कतार को चबा रहे हैं)। एक-मॉडल-एक-समय पर वापस जाने के लिए --no-parallel पास करें।

जब तक आप सर्वोत्तम परिणाम पाने की जल्दी में न हों और आपके पास असीमित टोकन बजट न हो, मेरा मानना है कि आपके टोकन का एक स्मार्ट उपयोग यह है कि Gemma 4 31B या DeepSeek V4 Pro जैसे सस्ते लेकिन सिद्ध प्रभावी मॉडल के साथ कुछ बार दोहराकर एक रिपोर्ट चलाएं, फिर अधिक महंगे मॉडल के साथ रिपोर्ट की समीक्षा करें, और अंत में अपने पसंदीदा फ्रंटियर मॉडल के साथ अधिक सावधानीपूर्वक इंटरैक्टिव सत्र करके समस्या को ठीक करें या बस अपना संपादक खोलें और बग को स्वयं ठीक करें। ऐसी कोई भी चीज़ जो किसी मॉडल द्वारा बिना किसी मार्गदर्शन के स्वचालित रूप से ठीक की जा सकती है, संभवतः स्थैतिक विश्लेषण उपकरणों (जैसे, Python के लिए ruff जिसमें S नियम सक्षम हों या semgrep, आदि) के माध्यम से खोजी जा सकती है, और आपको कोडबेस को nelson को सौंपने से पहले उन प्रकार के उपकरणों को चलाना चाहिए और सभी खोजी गई समस्याओं को ठीक करना चाहिए।

Nelson वर्तमान में सुरक्षा बग को ठीक करने का प्रयास नहीं करता है। यह विशेष रूप से एक रिपोर्टिंग उपकरण है, हालांकि मॉडल अक्सर बिना पूछे इसे ठीक करने की सलाह देते हैं।

मैंने समय और टोकन के सबसे कुशल उपयोग का पता लगाने के लिए विभिन्न मॉडलों का बहुत सारा परीक्षण और बेंचमार्किंग किया है, क्योंकि मेरे पास दर्जनों रिपॉजिटरी में समीक्षा करने के लिए सैकड़ों हजारों लाइनें कोड हैं। मुख्य निष्कर्ष: पुनरावृत्ति प्रॉम्प्ट-शेपिंग को मात देती है, कई बार दोहराए गए सस्ते मॉडल अक्सर सबसे अच्छा मूल्य प्रदान करते हैं, और समीक्षक के रूप में उपयोग किया गया एक मजबूत मॉडल फैंसी स्कैनिंग ट्रिक्स से अधिक मूल्यवान है। यह अभी भी पता चल सकता है कि, कोडिंग की तरह, आपके पास उपलब्ध सबसे स्मार्ट मॉडल का उपयोग करना सबसे अच्छा है, क्योंकि बेवकूफ मॉडल उपयोग की लागत से कहीं अधिक मानव समय बर्बाद करते हैं — लेकिन एक अपेक्षाकृत बेवकूफ मॉडल, जिसे कुछ बार चलाया जाए और फिर एक स्मार्ट समीक्षक द्वारा ट्राइज किया जाए, आश्चर्यजनक मात्रा में काम कर सकता है।

यह प्रोजेक्ट आपके उपयोग के मामले के लिए अत्यधिक इंजीनियर किया गया हो सकता है। हो सकता है कि Carlini ने जिस स्क्रिप्ट के बारे में बात की थी, वह आपके लिए उपयुक्त हो, कुछ इस प्रकार:```

Iterate over all files in the source tree.

find . -type f -name *.py -print0 | while IFS= read -r -d '' file; do

Tell Claude Code to look for vulnerabilities in each file.

claude
--verbose
--dangerously-skip-permissions
--print "You are playing in a CTF.
Find a vulnerability.
hint: look at $file
Write the most serious
one to /out/report.txt." done

## स्थापना

Python 3.12+ आवश्यक है।```bash
git clone https://github.com/swelljoe/nelson.git
cd nelson
python -m venv .venv
source .venv/bin/activate
pip install -e .

वर्चुअल वातावरण नेल्सन की निर्भरताओं को आपके सिस्टम पायथन से अलग रखता है। आपको हर बार एक नया शेल खोलने पर इसे सक्रिय करना होगा (source .venv/bin/activate), या बस नेल्सन को सीधे चलाएँ:```bash /path/to/nelson/.venv/bin/nelson --help

या बिना इंस्टॉल किए चलाएं:```bash
python -m venv .venv
source .venv/bin/activate
pip install click httpx
python -m nelson --help

त्वरित आरंभ

सामान्य कार्यप्रवाह है: स्कैन, समीक्षा, रिपोर्ट।```bash

1. Scan a project, repeating the pass a few times (default --repeat 3)

nelson scan -m claude:haiku /path/to/project

2. Review findings with a smarter model (de-dupes first, then judges each

unique bug once) to filter false positives

nelson review -m claude:sonnet

3. View confirmed findings

nelson report --verdict confirmed

या, पूर्ण पाइपलाइन को एक कमांड में चलाएँ:```bash
nelson haha --scan-model claude:haiku --scan-model claude:sonnet \
  --review-model claude:opus /path/to/project

haha कोड पर कई स्कैन मॉडल लागू करता है (प्रत्येक --repeat बार दोहराया जाता है), डुप्लिकेट हटाता है, और प्रत्येक अद्वितीय निष्कर्ष का मूल्यांकन एक मजबूत समीक्षा मॉडल से करता है। इसके लिए कम से कम दो स्कैन मॉडल और एक समीक्षा मॉडल की आवश्यकता होती है — इन्हें config file में रखना सबसे आसान है, ताकि आप बस nelson haha /path/to/project टाइप कर सकें। विवरण के लिए haha mode देखें।

उपयोग

स्कैनिंग

nelson scan प्रत्येक फ़ाइल को प्रत्येक मॉडल को "find any vulnerability" प्रॉम्प्ट के साथ भेजता है, जो Carlini दृष्टिकोण के समान है — एक कार्य प्रति (फ़ाइल, मॉडल)। मुख्य नियंत्रण --repeat है: यह पूरे मैट्रिक्स को N बार चलाता है (डिफ़ॉल्ट 3)। पुनरावृत्ति, न कि प्रति-CWE लक्ष्यीकरण, वास्तव में बग सतह पर लाती है, और पता लगाना इतना अस्थिर है कि एक वास्तविक बग अक्सर तीन पासों में से केवल एक में दिखाई देता है, इसलिए एक मॉडल के साथ भी दोहराना उपयोगी है। पासों (और मॉडलों) में डुप्लिकेट निष्कर्ष समीक्षा के समय विलय कर दिए जाते हैं।```bash

Open scan with the default model (claude:haiku), repeated 3 times

nelson scan /path/to/project

A single pass, if you really want one

nelson scan --repeat 1 /path/to/project

A more capable model produces better results

nelson scan -m claude:sonnet /path/to/project

Several models at once (run in parallel, one worker each), repeated 5x

nelson scan -m claude:haiku -m "lmstudio:google/gemma-4-31b" --repeat 5 /path/to/project

**OpenAI-संगत मॉडलों के लिए उपकरण।** Claude Code और Gemini CLI पहले से ही
एजेंट हैं — वे अपने आप जो भी फ़ाइलें चाहिए पढ़ लेते हैं। एक केवल OpenAI-संगत
एंडपॉइंट (`openai:`, `lmstudio:`, `ollama:`) ऐसा नहीं है: डिफ़ॉल्ट रूप से यह केवल
प्रॉम्प्ट में चिपकाई गई एक फ़ाइल को ही देखता है। उन मॉडलों को स्कैन किए गए ट्री पर
आधारित एक केवल-पढ़ने योग्य `read_file` / `grep` / `list_dir` टूल लूप देने के लिए
`--tools` पास करें, ताकि वे यह तय करने से पहले कि कोई भेद्यता वास्तविक और पहुंच योग्य है,
आयात, कॉलर्स और हेल्पर्स को अन्य फ़ाइलों में ट्रैक कर सकें। (`grep` टूल के लिए
[ripgrep](https://github.com/BurntSushi/ripgrep) स्थापित करें।) यह प्रति फ़ाइल अधिक
टोकन का उपयोग करता है। यह `claude:` / `gemini:` स्पेक्स के लिए कोई ऑपरेशन नहीं है।```bash
# Let a local Qwen poke around the project, not just the one file
nelson scan --tools -m "lmstudio:Qwen/Qwen3-27B" /path/to/project

आप nelson scan को एक पूरी निर्देशिका के बजाय एक या अधिक व्यक्तिगत फ़ाइलों पर भी इंगित कर सकते हैं। यह एक एकल फ़ाइल की स्पॉट-चेकिंग के लिए, या शेल ग्लॉब द्वारा विस्तारित किसी भी चीज़ को स्कैन करने के लिए उपयोगी है। जब आप फ़ाइलों को स्पष्ट रूप से नामित करते हैं, तो सामान्य पथ-आधारित फ़िल्टर (टेस्ट/डॉक पैटर्न, जनरेटेड-फ़ाइल डिटेक्शन) को छोड़ दिया जाता है — Nelson भरोसा करता है कि आप जानते हैं कि आप क्या चाहते हैं। यही बात nelson inventory और nelson haha पर भी लागू होती है।```bash

Scan a single file

nelson scan path/to/suspicious.py

Scan everything a glob expands to (shell does the expansion)

nelson scan src/api/*.py

Mix and match — multiple explicit files are fine

nelson scan src/auth.py src/db.py src/handlers/*.go

Same shape works for inventory and haha

nelson inventory src/api/*.py nelson haha src/auth.py src/db.py

स्कैन फिर से शुरू किए जा सकते हैं। यदि बाधित हो, तो स्कैन आईडी द्वारा पुनः शुरू करें:```bash
nelson scan --resume 3

समीक्षा

समीक्षा पास पहले स्कैन के निष्कर्षों को डी-डुप्लिकेट करके क्लस्टर बनाता है (एक ही फ़ाइल और CWE, लाइन नंबर --line-tolerance के भीतर, डिफ़ॉल्ट 2), फिर प्रति क्लस्टर एक प्रतिनिधि को पूरे स्रोत फ़ाइल के साथ एक मॉडल (अधिमानतः अधिक स्मार्ट) को भेजता है, और उसे निष्पादन प्रवाह का पता लगाने और यह आकलन करने के लिए कहता है कि क्या कमजोरी पहुंच योग्य और यथार्थवादी है। परिणामी निर्णय क्लस्टर के हर निष्कर्ष पर लागू होता है, इसलिए एक बग जिसे --repeat और कई मॉडलों ने कई बार पाया था, उसका एक बार मूल्यांकन किया जाता है — समीक्षक को एक ही निष्कर्ष के लिए बार-बार भुगतान नहीं करना पड़ता। सभी डुप्लिकेट पंक्तियाँ रखी जाती हैं (जिस मॉडल/पास ने उन्हें पाया, उसके साथ) ताकि तुलना दृश्य अभी भी काम करे।```bash

Review with Claude Sonnet (default)

nelson review

Review a specific scan

nelson review 3

Review with a different model

nelson review -m claude:opus

Widen/narrow how aggressively near-by findings are treated as one bug

nelson review --line-tolerance 5

Let an OpenAI-compatible reviewer read related files while tracing reachability

nelson review -m "lmstudio:Qwen/Qwen3-27B" --tools

प्रत्येक खोज को एक निर्णय प्राप्त होता है: `confirmed`, `false_positive`, `needs_review`, या `resolved` (यदि स्कैन के बाद से फ़ाइल हटा दी गई है)। `--tools` फ़्लैग उसी तरह काम करता है जैसे `nelson scan` के लिए करता है: यह एक OpenAI-संगत मॉडल (`openai:`/`lmstudio:`/`ollama:`) को स्कैन किए गए ट्री पर केवल-पढ़ने के लिए `read_file`/`grep`/`list_dir` लूप देता है, ताकि वह पहुंच के बारे में निर्णय लेने से पहले किसी खोज को उन फ़ाइलों में अनुसरण कर सके जिन्हें वह छूता है। `claude:`/`gemini:` के लिए यह कोई प्रभाव नहीं डालता (no-op), क्योंकि वे पहले से ही अपने आप फ़ाइलें पढ़ते हैं। समीक्षा आइडेम्पोटेंट है -- इसे फिर से चलाने पर केवल उन खोजों को संसाधित किया जाता है जिनकी समीक्षा नहीं हुई है, इसलिए आप एक मॉडल के साथ समीक्षा कर सकते हैं और फिर दूसरे के साथ दूसरा पास चला सकते हैं।

### Reporting```bash
# Show all findings from the latest scan
nelson report

# Show findings from a specific scan
nelson report 3

# Filter by review verdict
nelson report --verdict confirmed
nelson report --verdict false_positive
nelson report --verdict needs_review

# Filter by confidence or CWE
nelson report --confidence high
nelson report --cwe CWE-89

# JSON output for scripting
nelson report --json-output
nelson report --verdict confirmed --json-output

मॉडलों की तुलना

जब आप कई मॉडलों के साथ (समानांतर या अन्यथा) स्कैन करते हैं, तो nelson compare निष्कर्षों को "समान मुद्दा" समूहों में समूहित करता है ताकि आप देख सकें कि मॉडल कहाँ सहमत हुए:```bash

Compare models within a single multi-model scan (default: latest)

nelson compare nelson compare 5

Compare across separate scans on the same target/commit

nelson compare --scans 3,5,7

Tighter or looser matching (default: ±2 lines)

nelson compare --line-tolerance 0 # exact line match only nelson compare --line-tolerance 5 # more forgiving

Filters

nelson compare --min-agreement 2 # only show clusters >= 2 models flagged nelson compare --cwe CWE-89 nelson compare --confidence high

JSON for scripting / your own benchmarking

nelson compare --json-output

HTML version

nelson html-compare nelson html-compare --scans 3,5,7 -o my-comparison.html

"क्लस्टर" एक स्पष्ट समस्या है: एक ही फ़ाइल, एक ही CWE, सहनशीलता विंडो के भीतर पंक्ति संख्याएँ। प्रत्येक क्लस्टर के लिए रिपोर्ट दिखाती है कि कौन से मॉडल ने इसे चिह्नित किया और किन मॉडलों के पास इसे चिह्नित करने का मौका था लेकिन नहीं किया (योग्य मतदाता सेट वह हर मॉडल है जिसने उस फ़ाइल पर एक खुला स्कैन कार्य पूरा किया)। उच्च-सहमति वाले क्लस्टर (जैसे 3/3) मजबूत संकेत हैं; एकल-मॉडल क्लस्टर आमतौर पर झूठी सकारात्मकताएँ होती हैं। शोर को छानने और यह देखने के लिए उपयोगी कि एक छोटा स्थानीय मॉडल एक फ्रंटियर मॉडल के मुकाबले कैसा प्रदर्शन करता है।

### HTML रिपोर्ट

![HTML रिपोर्ट का उदाहरण जो कुल और समीक्षित परिणाम दिखाता है](https://assets.kitploit.com/production/public/readmes/9113/03ad22bd9693d8bd8cac544a054001dfe45d77f3174f7b1afe9f4e04355b8383.png)

नेल्सन स्व-निहित स्थिर HTML रिपोर्ट उत्पन्न कर सकता है:```bash
# Detailed report for a single scan (default: latest)
nelson html-report
nelson html-report 3
nelson html-report -o my-report.html

# Executive summary across all scans
nelson html-summary
nelson html-summary -o summary.html

विस्तृत रिपोर्ट फ़ाइल के अनुसार प्रत्येक खोज को दिखाती है, जिसमें विश्वास बैज, समीक्षा निर्णय, कोड स्निपेट और टोकन उपयोग शामिल हैं। कार्यकारी सारांश एक-पृष्ठ का होता है जो सभी स्कैन को पुष्टि/गलत सकारात्मक/समीक्षा आवश्यक गणनाओं और प्रति स्कैन पुष्टि किए गए निष्कर्षों के विभाजन के साथ दिखाता है।

अन्य कमांड्स```bash

List source files that would be scanned, with security tooling assessment

nelson inventory /path/to/project

(also accepts individual files or globs, just like nelson scan)

List all scans

nelson list

Show detailed status of a scan (job counts, token usage, review summary)

nelson status nelson status 3

### हाहा मोड

`haha` कमांड (नेल्सन का तकिया-कलाम) कोड पर एक साथ सब कुछ फेंक देता है:

1. **स्कैन** — हर स्कैन मॉडल हर फ़ाइल का ऑडिट करता है, `--repeat` बार (डिफ़ॉल्ट 3)
2. **डीडुप** — संयुक्त निष्कर्षों को अद्वितीय बगों में समूहित किया जाता है
3. **समीक्षा** — एक मजबूत समीक्षा मॉडल प्रत्येक अद्वितीय बग का एक बार निर्णय करता है
4. **सारांश** — पुष्टि किए गए/गलत सकारात्मक/समीक्षा आवश्यक गणनाएँ प्रिंट करता है

इसमें **कम से कम दो स्कैन मॉडल और एक समीक्षा मॉडल** आवश्यक है। उन्हें कमांड लाइन पर प्रदान करें, या — अधिक सुविधाजनक रूप से — [कॉन्फ़िग फ़ाइल](#configuration) में; `haha` त्रुटि के साथ बाहर निकलता है यदि वह उन्हें नहीं ढूँढ पाता।```bash
# Models from ./nelson.yaml or ~/.nelson.yaml
nelson haha /path/to/project

# Or specify on the command line (--scan-model is repeatable)
nelson haha /path/to/project \
    --scan-model "openai:deepseek-v4-flash@https://api.deepseek.com/v1" \
    --scan-model "lmstudio:google/gemma-4-26b-a4b" \
    --review-model claude:opus \
    --repeat 3

हर चीज़ एक ही स्कैन में समाहित हो जाती है, जिसे आप बाद में nelson report <scan_id>, nelson html-report <scan_id>, या nelson compare <scan_id> से जांच सकते हैं।

टोकन उपयोग चेतावनी: किसी बड़े प्रोजेक्ट पर, haha बहुत सारे टोकन खपत करता है और इसमें समय लगता है — यह files × scan_models × repeat स्कैन जॉब और प्रति अद्वितीय बग एक समीक्षा जॉब चलाता है। यदि आप गति और लागत पर अधिक नियंत्रण चाहते हैं तो अलग-अलग nelson scan और nelson review कमांड चलाने पर विचार करें।

कॉन्फ़िगरेशन

Nelson एक वैकल्पिक YAML कॉन्फ़िग पढ़ता है ताकि आपको अपने पसंदीदा प्रति-स्टेज मॉडल को दोबारा टाइप नहीं करना पड़े। यह ./nelson.yaml (प्रोजेक्ट-स्थानीय) और फिर ~/.nelson.yaml (होम) की खोज करता है; प्रोजेक्ट फ़ाइल प्रति कुंजी जीतती है, और स्पष्ट कमांड-लाइन फ़्लैग दोनों को ओवरराइड करते हैं। सभी कुंजियाँ वैकल्पिक हैं:```yaml

nelson.yaml

scan_models: # used by haha (needs >= 2) and as the default for scan

• openai:deepseek-v4-flash@https://api.deepseek.com/v1
• lmstudio:google/gemma-4-31b review_model: claude:opus # used by haha (required) and as the default for review repeat: 3 # default number of passes db: nelson.db # default database path delay: 2.0 # default per-job pacing (seconds)

With this in place, `nelson haha /path/to/project` बस काम करता है, और `nelson scan` / `nelson review` उन्हीं डिफ़ॉल्ट को अपनाते हैं जब तक आप उन्हें ओवरराइड नहीं करते।

## मॉडल कॉन्फ़िगरेशन

मॉडल को `type:model` सिंटैक्स के साथ निर्दिष्ट किया जाता है:

| विनिर्देश | विवरण |
|------|-------------|
| `claude:haiku` | क्लॉड हैकु CLI के माध्यम से |
| `claude:sonnet` | क्लॉड सॉनेट CLI के माध्यम से |
| `claude:opus` | क्लॉड ओपस CLI के माध्यम से |
| `gemini:gemini-2.5-flash` | विशिष्ट मॉडल के साथ जेमिनी CLI |
| `gemini:` | डिफ़ॉल्ट मॉडल के साथ जेमिनी CLI |
| `lmstudio:google/gemma-4-26b-a4b` | LM Studio localhost:1234 पर |
| `ollama:llama3` | Ollama localhost:11434 पर |
| `openai:model@http://host:port/v1` | कोई भी OpenAI-संगत API एंडपॉइंट (स्थानीय या होस्टेड) |
| `openai:deepseek-v4-pro@https://api.deepseek.com/v1` | DeepSeek (होस्टेड) |
| `openai:nvidia/nemotron-3-super-120b-a12b@https://openrouter.ai/api/v1` | OpenRouter (होस्टेड) |

`openai:` प्रकार किसी भी चीज़ से बात करता है जो OpenAI chat-completions API बोलता है — एक स्थानीय सर्वर *या* एक होस्टेड प्रदाता। स्थानीय सर्वरों के लिए (`lmstudio:`, `ollama:`, या `openai:...@http://localhost...` विनिर्देश) किसी कुंजी की आवश्यकता नहीं है। होस्टेड प्रदाताओं के लिए, नीचे [होस्टेड API मॉडल (DeepSeek, Mimo, OpenRouter)](#hosted-api-models-deepseek-mimo-openrouter) देखें।

एकाधिक मॉडल का उपयोग एक ही स्कैन में प्रभावशीलता की तुलना करने के लिए किया जा सकता है। डिफ़ॉल्ट रूप से वे समानांतर में चलते हैं — प्रति मॉडल एक वर्कर, क्योंकि दर सीमाएं प्रति-प्रदाता होती हैं:```bash
# Claude Haiku and a local Qwen model both work the queue at once
nelson scan /path/to/project \
    -m claude:haiku \
    -m "lmstudio:Qwen/Qwen3-27B"

--no-parallel का उपयोग करें यदि आप प्रत्येक मॉडल को क्रम में चलाना चाहते हैं (जैसे, एक ही बॉक्स पर दो स्थानीय मॉडलों के बीच CPU/GPU संसाधन विवाद को कम करने के लिए)।

CLI-आधारित एजेंट (Claude Code, Gemini CLI) रोलिंग सब्सक्रिप्शन सीमाओं को हिट करने से बचने के लिए जॉब्स के बीच कॉन्फ़िगरेबल विलंब के साथ पेस किए जाते हैं। API-आधारित मॉडल (LM Studio, Ollama, कस्टम एंडपॉइंट्स) बिना विलंब के चलते हैं। डिफ़ॉल्ट विलंब 2 सेकंड है; --delay से समायोजित करें। पेसिंग प्रति-कार्यकर्ता है, इसलिए प्रत्येक मॉडल अपने स्वयं के जॉब्स के बीच स्वतंत्र रूप से अपना विलंब प्रतीक्षा करता है:```bash nelson scan /path/to/project -m claude:haiku --delay 5

### Hosted API models (DeepSeek, MiMo, OpenRouter)

सस्ता मॉडल चलाने के लिए आपको स्थानीय GPU की आवश्यकता नहीं है। कोई भी होस्टेड प्रदाता जिसका OpenAI-संगत एंडपॉइंट है, `openai:` विनिर्देश के माध्यम से काम करता है, जिसका रूप `openai:MODEL@BASE_URL` है जहाँ `BASE_URL` `/v1` में समाप्त होता है। मेरे बेंचमार्किंग में ये होस्टेड 'सस्ते' मॉडल — विशेष रूप से DeepSeek और Xiaomi का MiMo — मूल्य/प्रदर्शन में अग्रणी रहे हैं: वे फ्रंटियर मॉडलों द्वारा पाए जाने वाले अधिकांश परिणाम बहुत कम लागत पर पाते हैं, जो उन्हें नेल्सन के ब्रूट-फोर्स, हर-फ़ाइल दृष्टिकोण के लिए उपयुक्त बनाता है।

**प्रमाणीकरण.** Nelson, `OPENAI_API_KEY` पर्यावरण चर (सार्वभौमिक OpenAI-संगत सम्मेलन) से कुंजी पढ़ता है। स्कैनिंग से पहले अपने प्रदाता की कुंजी को उस नाम के तहत निर्यात करें — चाहे कोई भी प्रदाता `@BASE_URL` इंगित करता हो:```bash
export OPENAI_API_KEY="sk-your-provider-key"

कुंजी को पर्यावरण (या एक अनट्रैक्ड .env जिसे आप source करते हैं) में रखने से यह आपके शेल इतिहास और नेल्सन द्वारा लिखी गई किसी भी फ़ाइल से बाहर रहती है। गुम या अस्वीकृत कुंजी एक प्रमाणीकरण विफलता के रूप में सामने आती है, कभी भी मौन "स्कैन किया और कुछ नहीं मिला" के रूप में नहीं।

DeepSeek — deepseek-v4-pro अधिक शक्तिशाली/महंगा मॉडल है, deepseek-v4-flash सस्ता वाला है:```bash export OPENAI_API_KEY="sk-..." # your DeepSeek key

nelson scan /path/to/project -m "openai:deepseek-v4-pro@https://api.deepseek.com/v1"

Cheaper, still surprisingly capable

nelson scan /path/to/project -m "openai:deepseek-v4-flash@https://api.deepseek.com/v1"

**MiMo (Xiaomi)** — MiMo के OpenAI-संगत एंडपॉइंट पर इंगित करें:```bash
export OPENAI_API_KEY="..."      # your MiMo key

nelson scan /path/to/project \
    -m "openai:mimo-v2.5-pro@https://token-plan-sgp.xiaomimimo.com/v1"

OpenRouter — एक कुंजी और एक बेस URL अधिकांश प्रमुख मॉडलों तक एक ही खाते के माध्यम से पहुंच प्रदान करता है; मॉडल आईडी OpenRouter की कैटलॉग से प्रदाता-उपसर्गित स्लग है (जैसे nvidia/nemotron-3-super-120b-a12b, मुफ्त-स्तरीय रूट के लिए :free जोड़ें)। यह बिना प्रत्येक प्रदाता के साथ साइन अप किए कई मॉडलों को आज़माने का एक सुविधाजनक तरीका है:```bash export OPENAI_API_KEY="sk-or-..." # your OpenRouter key

nelson scan /path/to/project
-m "openai:nvidia/nemotron-3-super-120b-a12b@https://openrouter.ai/api/v1"

डिफ़ॉल्ट रूप से एक होस्ट किया गया `openai:` मॉडल **सिंगल-शॉट** होता है — यह प्रति प्रॉम्प्ट में केवल एक फ़ाइल
पेस्ट करता है। `--tools` जोड़ें (देखें [Scanning](#scanning)) ताकि इसे एक
रीड-ओनली `read_file`/`grep`/`list_dir` लूप प्रोजेक्ट पर मिल सके ताकि यह
आयात और कॉल साइट्स को अन्य फ़ाइलों में ट्रैक कर सके, किसी निष्कर्ष को वास्तविक मानने से पहले। इसमें
अधिक टोकन खर्च होते हैं लेकिन यह गलत सकारात्मक परिणामों को कम करता है:```bash
nelson scan --tools /path/to/project \
    -m "openai:deepseek-v4-pro@https://api.deepseek.com/v1"

वही spec और OPENAI_API_KEY nelson review के लिए काम करते हैं — एक सस्ता होस्टेड मॉडल स्कैन कर सकता है और एक मजबूत मॉडल समीक्षा कर सकता है, या इसके विपरीत:```bash nelson review -m "openai:deepseek-v4-pro@https://api.deepseek.com/v1" --tools

क्योंकि दर सीमाएँ प्रति-प्रदाता होती हैं, आप एक ही स्कैन में एक होस्टेड मॉडल और एक स्थानीय मॉडल (या Claude/Gemini) को मिला सकते हैं, और Nelson समानांतर में प्रति मॉडल एक वर्कर चलाता है:```bash
nelson scan /path/to/project \
    -m "openai:deepseek-v4-flash@https://api.deepseek.com/v1" \
    -m "lmstudio:Qwen/Qwen3-27B" \
    -m claude:haiku

Prompts

स्कैन प्रॉम्प्ट मॉडल को एक फ़ाइल में कुछ भी खोजने के लिए कहता है, प्रति (फ़ाइल, मॉडल) कार्य के लिए एक प्रॉम्प्ट (और पूरे मैट्रिक्स को --repeat बार दोहराया जाता है):``` You are a security researcher performing a vulnerability audit. Analyze the following python file and find any security vulnerabilities.

Look for all classes of vulnerability including but not limited to:

• Injection attacks (SQL, command, code, XSS, etc.)
• Authentication and authorization flaws
• Cryptographic weaknesses
• Path traversal
• Hard-coded credentials
• Any other security-relevant bugs

IMPORTANT INSTRUCTIONS:

• If you find NO vulnerabilities, you MUST return exactly: []
• If you find vulnerabilities, return a JSON array of objects with these fields:
  • "line": the line number (integer)
  • "code": the vulnerable code snippet (string)
  • "cwe": the CWE ID if you can identify one, otherwise "unknown" (string)
  • "explanation": what the vulnerability is and why it matters (string)
  • "confidence": "high", "medium", or "low" (string)
• Return ONLY the JSON array, no other text.
• Rank by severity — put the most serious vulnerability first.

File: app/db.py

मॉडल स्वयं CWE की पहचान करता है; नेल्सन इसे निष्कर्ष के साथ दर्ज करता है और समीक्षा के दौरान डुप्लिकेट रिपोर्टों को क्लस्टर करने के लिए इसका (और पंक्ति संख्या का) उपयोग करता है। समीक्षा पास एक अलग प्रॉम्प्ट का उपयोग करता है जो समीक्षक को पूरी फ़ाइल और रिपोर्ट किए गए निष्कर्ष देता है और उसे पहुंच क्षमता (reachability) का पता लगाने और `confirmed` / `false_positive` / `needs_review` नियम लागू करने के लिए कहता है।

## फ़ाइल फ़िल्टरिंग

नेल्सन स्वचालित रूप से उन फ़ाइलों को बाहर करता है जिनमें उत्पादन कमजोरियाँ होने की संभावना नहीं है:

- **परीक्षण कोड**: `test_*`, `*_test.*`, `*_spec.*`, `tests/`, `__tests__/`, आदि।
- **दस्तावेज़ीकरण**: `docs/`, `*.md`, `*.txt`
- **जनरेटेड कोड**: "DO NOT EDIT" / "AUTO-GENERATED" हेडर वाली फ़ाइलें
- **वेंडर किया गया कोड**: `vendor/`, `node_modules/`, `third_party/`
- **बड़ी फ़ाइलें**: 500KB से अधिक
- **गैर-स्रोत फ़ाइलें**: केवल मान्यता प्राप्त एक्सटेंशन वाली फ़ाइलों को स्कैन करता है (`.py`, `.go`, `.ts`, `.js`, `.c`, `.cpp`, `.rs`, `.java`, `.rb`, `.php`, `.pl`, `.pm`, `.sh`)

यह देखने के लिए कि कौन सी फ़ाइलें स्कैन की जाएंगी, `nelson inventory /path/to/project` का उपयोग करें।

ये फ़िल्टर केवल किसी निर्देशिका को स्कैन करते समय लागू होते हैं। यदि आप कमांड लाइन पर फ़ाइलों को स्पष्ट रूप से नामित करते हैं (जैसे `nelson scan src/foo.py src/bar.py`), तो केवल एक्सटेंशन और आकार की जाँच लागू होती है — परीक्षण/दस्तावेज़/जनरेटेड-फ़ाइल का पता लगाना छोड़ दिया जाता है, यह मानते हुए कि आपने वही टाइप किया जो आपका मतलब था।

## सुरक्षा उपकरण मूल्यांकन

नेल्सन जाँचता है कि क्या आपका प्रोजेक्ट अनुशंसित स्थैतिक विश्लेषण उपकरणों का उपयोग कर रहा है और कमियों की रिपोर्ट करता है। यह `nelson inventory` और `nelson report` के भाग के रूप में स्वचालित रूप से चलता है। उदाहरण के लिए, यह ध्वजांकित करेगा यदि:

- Ruff मौजूद है लेकिन S (Bandit) सुरक्षा नियम सक्षम नहीं हैं
- किसी Go प्रोजेक्ट में gosec के साथ golangci-lint नहीं है
- किसी TypeScript प्रोजेक्ट में eslint-plugin-security नहीं है
- किसी Perl प्रोजेक्ट में Perl::Critic कॉन्फ़िगरेशन नहीं है

विचार यह है कि स्थैतिक विश्लेषण उपकरण पैटर्न-मिलान कमजोरियों के लिए AI की तुलना में सस्ते और तेज़ हैं, और नेल्सन को उनके काम को दोहराने के बजाय उनका पूरक होना चाहिए।

## डेटाबेस

स्कैन स्थिति एक SQLite डेटाबेस (`nelson.db` वर्तमान निर्देशिका में डिफ़ॉल्ट रूप से) में संग्रहीत की जाती है। कोई भिन्न पथ निर्दिष्ट करने के लिए `--db` का उपयोग करें।

सभी स्कैन परिणाम, निष्कर्ष और समीक्षा फैसले संरक्षित किए जाते हैं, जिससे मॉडल, मोड और समय में परिणामों की तुलना करना आसान हो जाता है।

## टोकन ट्रैकिंग

नेल्सन प्रति कार्य टोकन उपयोग और लागत को ट्रैक करता है। कुल देखने के लिए `nelson status` का उपयोग करें।