@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/domains/chemistry/spectroscopy-analysis-guide/SKILL.md

@@ -0,0 +1,290 @@
+---
+name: spectroscopy-analysis-guide
+description: "Spectral data analysis for NMR, IR, mass spectrometry, and UV-Vis"
+metadata:
+  openclaw:
+    emoji: "microscope"
+    category: "domains"
+    subcategory: "chemistry"
+    keywords: ["spectroscopy", "nmr", "mass-spectrometry", "infrared", "uv-vis", "analytical-chemistry"]
+    source: "wentor"
+---
+
+# Spectroscopy Analysis Guide
+
+A skill for processing and interpreting spectroscopic data in chemistry research. Covers NMR, IR, mass spectrometry, and UV-Vis spectroscopy including data formats, baseline correction, peak detection, spectral matching, and structure elucidation workflows.
+
+## Spectral Data Formats
+
+### Common File Formats
+
+| Format | Spectroscopy | Description |
+|--------|-------------|-------------|
+| JCAMP-DX (.jdx, .dx) | All types | IUPAC standard exchange format |
+| Bruker (1r, fid, acqu) | NMR | Raw and processed Bruker data |
+| mzML / mzXML | MS | Open mass spectrometry format |
+| SPC (.spc) | IR, UV-Vis | Galactic/Thermo spectral format |
+| CSV / TXT | All | Simple x,y pairs (wavelength/wavenumber, intensity) |
+
+### Reading Spectral Data
+
+```python
+import numpy as np
+from scipy.signal import find_peaks, savgol_filter
+
+def read_jcamp(filepath: str) -> dict:
+    """
+    Read a JCAMP-DX spectral file.
+    Returns x (wavenumber/chemical shift/m/z) and y (intensity) arrays.
+    """
+    x_data, y_data = [], []
+    metadata = {}
+
+    with open(filepath, "r") as f:
+        for line in f:
+            line = line.strip()
+            if line.startswith("##"):
+                key_val = line[2:].split("=", 1)
+                if len(key_val) == 2:
+                    metadata[key_val[0].strip()] = key_val[1].strip()
+            elif line and not line.startswith("$$"):
+                parts = line.split()
+                try:
+                    values = [float(v) for v in parts]
+                    if len(values) >= 2:
+                        x_data.append(values[0])
+                        y_data.extend(values[1:])
+                except ValueError:
+                    continue
+
+    return {
+        "x": np.array(x_data),
+        "y": np.array(y_data[:len(x_data)]),
+        "metadata": metadata,
+    }
+```
+
+## NMR Spectroscopy
+
+### 1H NMR Processing
+
+```python
+import nmrglue as ng
+
+def process_1h_nmr(bruker_dir: str) -> dict:
+    """
+    Process 1H NMR data from Bruker format using nmrglue.
+    bruker_dir: path to Bruker experiment directory
+    """
+    # Read raw data
+    dic, data = ng.bruker.read(bruker_dir)
+
+    # Apply processing
+    data = ng.bruker.remove_digital_filter(dic, data)
+    data = ng.proc_base.zf_size(data, 65536)     # zero-fill
+    data = ng.proc_base.fft(data)                  # Fourier transform
+    data = ng.proc_autophase.autops(data, "acme")  # automatic phasing
+    data = ng.proc_base.rev(data)                  # reverse spectrum
+    data = ng.proc_base.di(data)                   # discard imaginary
+
+    # Generate chemical shift axis (ppm)
+    udic = ng.bruker.guess_udic(dic, data)
+    uc = ng.fileiobase.uc_from_udic(udic)
+    ppm = uc.ppm_scale()
+
+    return {
+        "ppm": ppm,
+        "spectrum": data.real,
+        "sf": dic["acqus"]["SFO1"],       # spectrometer frequency (MHz)
+        "sw_ppm": dic["acqus"]["SW"],       # sweep width (ppm)
+    }
+
+def pick_nmr_peaks(ppm: np.ndarray, spectrum: np.ndarray,
+                    threshold: float = 0.05) -> list[dict]:
+    """
+    Automatic peak picking for 1H NMR.
+    threshold: minimum peak height as fraction of max intensity.
+    """
+    min_height = threshold * np.max(spectrum)
+    indices, properties = find_peaks(
+        spectrum, height=min_height, distance=10, prominence=min_height * 0.5
+    )
+
+    peaks = []
+    for idx in indices:
+        peaks.append({
+            "ppm": round(float(ppm[idx]), 3),
+            "intensity": float(spectrum[idx]),
+        })
+
+    # Sort by chemical shift (high to low, NMR convention)
+    peaks.sort(key=lambda p: p["ppm"], reverse=True)
+    return peaks
+```
+
+### Common 1H NMR Chemical Shift Ranges
+
+| Chemical Shift (ppm) | Functional Group |
+|----------------------|-----------------|
+| 0.8-1.0 | CH3 (methyl, alkyl) |
+| 1.2-1.4 | CH2 (methylene, alkyl chain) |
+| 2.0-2.5 | CH next to C=O |
+| 3.3-3.9 | CH next to O or N (ethers, amines) |
+| 4.5-5.5 | Vinyl C=CH2, OCH |
+| 6.5-8.5 | Aromatic H |
+| 9.0-10.0 | Aldehyde CHO |
+| 10.0-12.0 | Carboxylic acid OH |
+
+## Mass Spectrometry
+
+### Processing MS Data
+
+```python
+from pyteomics import mzml
+import numpy as np
+
+def read_mzml_spectra(filepath: str, ms_level: int = 1) -> list[dict]:
+    """
+    Read mass spectra from an mzML file.
+    ms_level: 1 for MS1 (survey scans), 2 for MS/MS
+    """
+    spectra = []
+    with mzml.read(filepath) as reader:
+        for spectrum in reader:
+            if spectrum.get("ms level") == ms_level:
+                spectra.append({
+                    "scan": spectrum["index"],
+                    "rt": spectrum["scanList"]["scan"][0].get(
+                        "scan start time", 0
+                    ),
+                    "mz": spectrum["m/z array"],
+                    "intensity": spectrum["intensity array"],
+                    "tic": np.sum(spectrum["intensity array"]),
+                })
+    return spectra
+
+def find_molecular_ion(mz: np.ndarray, intensity: np.ndarray,
+                        expected_mw: float = None,
+                        tolerance_da: float = 0.5) -> list[dict]:
+    """
+    Identify molecular ion peaks ([M+H]+, [M+Na]+, [M-H]-).
+    """
+    # Find top peaks
+    top_indices = np.argsort(intensity)[::-1][:20]
+    candidates = []
+
+    adducts = {
+        "[M+H]+": 1.00728,
+        "[M+Na]+": 22.98922,
+        "[M+K]+": 38.96316,
+        "[M-H]-": -1.00728,
+        "[M+NH4]+": 18.03437,
+    }
+
+    for idx in top_indices:
+        peak_mz = mz[idx]
+        peak_int = intensity[idx]
+
+        if expected_mw:
+            for adduct_name, adduct_mass in adducts.items():
+                calc_mw = peak_mz - adduct_mass
+                if abs(calc_mw - expected_mw) < tolerance_da:
+                    candidates.append({
+                        "mz": round(float(peak_mz), 4),
+                        "intensity": float(peak_int),
+                        "adduct": adduct_name,
+                        "calc_mw": round(calc_mw, 4),
+                        "error_da": round(abs(calc_mw - expected_mw), 4),
+                    })
+        else:
+            candidates.append({
+                "mz": round(float(peak_mz), 4),
+                "intensity": float(peak_int),
+            })
+
+    return candidates
+```
+
+## Infrared Spectroscopy
+
+### IR Peak Assignment
+
+```python
+# Standard IR functional group frequency table
+IR_ASSIGNMENTS = {
+    (3200, 3600): "O-H stretch (broad: alcohol, acid; sharp: free OH)",
+    (3300, 3500): "N-H stretch (primary amine: 2 bands; secondary: 1 band)",
+    (2850, 3000): "C-H stretch (sp3: 2850-2960; sp2: 3000-3100)",
+    (2100, 2260): "Triple bond stretch (C-triple-N: 2210-2260; C-triple-C: 2100-2150)",
+    (1680, 1750): "C=O stretch (ketone ~1715; ester ~1735; acid ~1710; amide ~1650)",
+    (1600, 1680): "C=C stretch (alkene ~1640; aromatic ~1600, 1500)",
+    (1000, 1300): "C-O stretch (ether, ester, alcohol)",
+}
+
+def assign_ir_peaks(wavenumber: np.ndarray, absorbance: np.ndarray,
+                     threshold: float = 0.1) -> list[dict]:
+    """Detect and assign IR absorption peaks to functional groups."""
+    # Invert for peak detection (absorbance peaks are positive)
+    peaks, properties = find_peaks(absorbance, height=threshold, prominence=0.05)
+
+    assignments = []
+    for idx in peaks:
+        wn = float(wavenumber[idx])
+        assignment = "unassigned"
+        for (low, high), group in IR_ASSIGNMENTS.items():
+            if low <= wn <= high:
+                assignment = group
+                break
+        assignments.append({
+            "wavenumber_cm-1": round(wn, 1),
+            "absorbance": round(float(absorbance[idx]), 4),
+            "assignment": assignment,
+        })
+
+    return sorted(assignments, key=lambda x: x["wavenumber_cm-1"], reverse=True)
+```
+
+## Spectral Processing Utilities
+
+### Baseline Correction and Smoothing
+
+```python
+def baseline_correction(y: np.ndarray, lam: float = 1e6,
+                         p: float = 0.001, n_iter: int = 10) -> np.ndarray:
+    """
+    Asymmetric least squares baseline correction (Eilers and Boelens, 2005).
+    lam: smoothness parameter (larger = smoother baseline)
+    p: asymmetry parameter (smaller = more emphasis on fitting below peaks)
+    """
+    from scipy.sparse import diags, csc_matrix
+    from scipy.sparse.linalg import spsolve
+
+    L = len(y)
+    D = diags([1, -2, 1], [0, -1, -2], shape=(L, L - 2)).toarray()
+    H = lam * D.dot(D.T)
+    w = np.ones(L)
+
+    for _ in range(n_iter):
+        W = diags(w, 0, shape=(L, L))
+        Z = csc_matrix(W + H)
+        baseline = spsolve(Z, w * y)
+        w = p * (y > baseline) + (1 - p) * (y < baseline)
+
+    return y - baseline
+
+def smooth_spectrum(y: np.ndarray, window: int = 11,
+                     polyorder: int = 3) -> np.ndarray:
+    """Apply Savitzky-Golay smoothing to a spectrum."""
+    return savgol_filter(y, window, polyorder)
+```
+
+## Tools and Software
+
+- **nmrglue**: Python NMR data processing (Bruker, Varian, Agilent)
+- **pyOpenMS / pyteomics**: Mass spectrometry data processing
+- **RDKit**: Molecular structure to predicted spectra
+- **MestReNova**: Commercial NMR processing (widely used in chemistry labs)
+- **TopSpin (Bruker)**: NMR acquisition and processing
+- **SDBS (AIST)**: Free spectral database (IR, NMR, MS)
+- **MassBank**: Open mass spectral database
+- **NIST Chemistry WebBook**: Reference spectra for IR and MS

package/skills/domains/cs/ai-security-papers-guide/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: ai-security-papers-guide
+description: "AI security papers from top-4 security conferences"
+metadata:
+  openclaw:
+    emoji: "🛡️"
+    category: "domains"
+    subcategory: "cs"
+    keywords: ["AI security", "adversarial ML", "model attacks", "S&P", "CCS", "USENIX", "NDSS"]
+    source: "https://github.com/Zhou-Zi7/Awesome-AI-Security-BIG4"
+---
+
+# AI Security Papers Guide (BIG4 Venues)
+
+## Overview
+
+A curated collection of AI security papers from the top-4 security conferences: IEEE S&P, ACM CCS, USENIX Security, and NDSS. Covers adversarial attacks, model stealing, data poisoning, privacy attacks, deepfake detection, and LLM security. Organized by year and venue, focusing exclusively on peer-reviewed work from these prestigious venues.
+
+## Venues
+
+| Venue | Full Name | Focus |
+|-------|-----------|-------|
+| **S&P** | IEEE Symposium on Security and Privacy | Broad security + privacy |
+| **CCS** | ACM Conference on Computer and Communications Security | Systems security |
+| **USENIX** | USENIX Security Symposium | Systems + network security |
+| **NDSS** | Network and Distributed System Security | Network security |
+
+## Topic Categories
+
+```
+AI Security (BIG4)
+├── Adversarial ML
+│   ├── Evasion attacks (adversarial examples)
+│   ├── Poisoning attacks (backdoors, trojans)
+│   ├── Model stealing (extraction, distillation)
+│   └── Defenses (certified robustness, detection)
+├── Privacy Attacks
+│   ├── Membership inference
+│   ├── Model inversion
+│   ├── Attribute inference
+│   └── Training data extraction
+├── LLM Security
+│   ├── Prompt injection
+│   ├── Jailbreaking
+│   ├── Data leakage
+│   └── Alignment attacks
+├── Deepfakes
+│   ├── Generation methods
+│   ├── Detection techniques
+│   └── Watermarking
+└── Federated Learning Security
+    ├── Byzantine attacks
+    ├── Gradient leakage
+    └── Secure aggregation
+```
+
+## Key Papers by Year
+
+```python
+# Recent highlights
+papers_2024_2025 = [
+    {"title": "Not What You've Signed Up For: "
+              "Compromising Real-World LLM-Integrated Applications",
+     "venue": "S&P 2024", "topic": "LLM security"},
+    {"title": "Prompt Stealing Attacks Against "
+              "Text-to-Image Generation Models",
+     "venue": "S&P 2024", "topic": "Prompt extraction"},
+    {"title": "Backdoor Attacks on Language Models",
+     "venue": "CCS 2024", "topic": "NLP backdoors"},
+    {"title": "Membership Inference in LLMs",
+     "venue": "USENIX 2024", "topic": "Privacy"},
+]
+
+for p in papers_2024_2025:
+    print(f"[{p['venue']}] {p['title']}")
+    print(f"  Topic: {p['topic']}")
+```
+
+## Research Trends
+
+```markdown
+### Emerging Areas (2024-2025)
+1. **LLM security** — Jailbreaking, prompt injection, agent attacks
+2. **Supply chain attacks** — Poisoned models, malicious packages
+3. **Multi-modal attacks** — Cross-modal adversarial examples
+4. **Agent security** — Attacks on LLM-based autonomous systems
+5. **Watermarking** — LLM output detection, IP protection
+6. **Unlearning** — Machine unlearning verification and attacks
+```
+
+## Use Cases
+
+1. **Security research**: Find state-of-the-art attack/defense methods
+2. **Threat modeling**: Understand AI system vulnerabilities
+3. **Literature review**: Systematic coverage of BIG4 AI security
+4. **Course material**: Graduate-level AI security curriculum
+5. **Red teaming**: Learn evaluation techniques for AI systems
+
+## References
+
+- [Awesome-AI-Security-BIG4](https://github.com/Zhou-Zi7/Awesome-AI-Security-BIG4)
+- [IEEE S&P](https://www.ieee-security.org/TC/SP-Index.html)
+- [ACM CCS](https://www.sigsac.org/ccs/)

package/skills/domains/cs/code-llm-papers-guide/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: code-llm-papers-guide
+description: "Survey and paper collection on LLMs for code generation"
+metadata:
+  openclaw:
+    emoji: "💻"
+    category: "domains"
+    subcategory: "cs"
+    keywords: ["Code LLM", "code generation", "program synthesis", "Codex", "code intelligence", "software engineering"]
+    source: "https://github.com/codefuse-ai/Awesome-Code-LLM"
+---
+
+# Code LLM Papers Guide
+
+## Overview
+
+This curated collection covers LLMs for code — from foundational models (Codex, CodeGen, StarCoder) through code generation, completion, repair, translation, and understanding. Accompanies a TMLR survey paper providing systematic categorization. Tracks 500+ papers across pre-training, fine-tuning, evaluation, and application of code-focused language models.
+
+## Taxonomy
+
+```
+Code LLMs
+├── Pre-training
+│   ├── Encoder-only (CodeBERT, GraphCodeBERT)
+│   ├── Decoder-only (Codex, CodeGen, StarCoder, DeepSeek-Coder)
+│   └── Encoder-Decoder (CodeT5, PLBART)
+├── Fine-tuning & Alignment
+│   ├── Instruction tuning (WizardCoder, Magicoder)
+│   ├── RLHF for code (CodeRL)
+│   └── Self-play (AlphaCode)
+├── Applications
+│   ├── Code generation (NL → Code)
+│   ├── Code completion (infilling)
+│   ├── Code repair (bug fixing)
+│   ├── Code translation (language conversion)
+│   ├── Code summarization (Code → NL)
+│   ├── Test generation
+│   └── Code review
+└── Evaluation
+    ├── Benchmarks (HumanEval, MBPP, SWE-bench)
+    ├── Metrics (pass@k, CodeBLEU)
+    └── Security analysis
+```
+
+## Key Models Timeline
+
+| Model | Year | Organization | Parameters | Key Innovation |
+|-------|------|-------------|------------|----------------|
+| **CodeBERT** | 2020 | Microsoft | 125M | Bimodal NL-PL pre-training |
+| **Codex** | 2021 | OpenAI | 12B | GPT-3 fine-tuned on GitHub |
+| **AlphaCode** | 2022 | DeepMind | 41B | Competitive programming |
+| **StarCoder** | 2023 | BigCode | 15B | Fill-in-the-middle, 1T tokens |
+| **CodeLlama** | 2023 | Meta | 34B | Llama 2 + code specialization |
+| **DeepSeek-Coder** | 2024 | DeepSeek | 33B | 2T token project-level training |
+| **Qwen2.5-Coder** | 2024 | Alibaba | 32B | 5.5T tokens, multi-language |
+
+## Benchmark Tracking
+
+```python
+# Track model performance on HumanEval
+humaneval_scores = {
+    "GPT-4": {"pass_at_1": 67.0, "pass_at_10": 86.0},
+    "Claude 3.5 Sonnet": {"pass_at_1": 64.0},
+    "DeepSeek-Coder-33B": {"pass_at_1": 56.1},
+    "CodeLlama-34B": {"pass_at_1": 48.8},
+    "StarCoder2-15B": {"pass_at_1": 46.3},
+    "GPT-3.5-Turbo": {"pass_at_1": 48.1},
+}
+
+print(f"{'Model':<25} {'pass@1':>8} {'pass@10':>8}")
+print("-" * 43)
+for model, scores in sorted(
+    humaneval_scores.items(),
+    key=lambda x: x[1].get("pass_at_1", 0),
+    reverse=True,
+):
+    p1 = scores.get("pass_at_1", "—")
+    p10 = scores.get("pass_at_10", "—")
+    print(f"{model:<25} {str(p1):>8} {str(p10):>8}")
+```
+
+## Research Directions
+
+```markdown
+### Active Areas (2024-2025)
+1. **Repository-level generation** — Understanding full codebases
+2. **Agentic coding** — LLMs using tools (debugger, terminal)
+3. **Formal verification** — Proving correctness of generated code
+4. **Multi-language** — Cross-language transfer and translation
+5. **Security** — Detecting and avoiding vulnerable code
+6. **Long context** — Processing large codebases (100k+ tokens)
+7. **Code editing** — Natural language instructions for code changes
+```
+
+## Paper Search
+
+```python
+import arxiv
+
+def find_code_llm_papers(topic="code generation", max_results=20):
+    """Find recent Code LLM papers on arXiv."""
+    query = f"abs:{topic} AND (abs:large language model OR abs:LLM)"
+
+    search = arxiv.Search(
+        query=query,
+        max_results=max_results,
+        sort_by=arxiv.SortCriterion.SubmittedDate,
+    )
+
+    for result in search.results():
+        print(f"[{result.published.strftime('%Y-%m-%d')}] "
+              f"{result.title}")
+
+find_code_llm_papers("code generation")
+find_code_llm_papers("automated program repair")
+```
+
+## Use Cases
+
+1. **Literature survey**: Map the Code LLM research landscape
+2. **Model selection**: Compare code models for specific tasks
+3. **Benchmark analysis**: Track state-of-the-art on standard benchmarks
+4. **Research planning**: Identify open problems and trends
+5. **Course material**: Teach software engineering + AI intersection
+
+## References
+
+- [Awesome-Code-LLM](https://github.com/codefuse-ai/Awesome-Code-LLM)
+- [TMLR Survey Paper](https://arxiv.org/abs/2311.07989)
+- [HumanEval](https://github.com/openai/human-eval)
+- [SWE-bench](https://www.swebench.com/)