@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/domains/pharma/clinical-trial-design-guide/SKILL.md

@@ -0,0 +1,271 @@
+---
+name: clinical-trial-design-guide
+description: "Clinical trial methodology, biostatistics, and study design guidance"
+metadata:
+  openclaw:
+    emoji: "test-tube"
+    category: "domains"
+    subcategory: "pharma"
+    keywords: ["clinical-trial", "biostatistics", "randomization", "sample-size", "survival-analysis", "rct"]
+    source: "wentor"
+---
+
+# Clinical Trial Design Guide
+
+A skill for designing and analyzing clinical trials, covering study design selection, sample size calculation, randomization methods, interim analysis, survival endpoints, and regulatory considerations. Essential for pharmaceutical researchers, biostatisticians, and clinical scientists.
+
+## Clinical Trial Phases
+
+### Phase Overview
+
+| Phase | Objective | Typical N | Duration | Primary Endpoints |
+|-------|-----------|----------|----------|-------------------|
+| Phase I | Safety, dose-finding | 20-80 | Months | MTD, DLT, PK profile |
+| Phase II | Efficacy signal, dosing | 100-300 | 1-2 years | Response rate, biomarker |
+| Phase III | Confirmatory efficacy | 300-3,000+ | 2-4 years | OS, PFS, clinical outcome |
+| Phase IV | Post-marketing surveillance | 1,000+ | Ongoing | Safety, real-world effectiveness |
+
+## Study Design Selection
+
+### Common Designs
+
+```
+Parallel Group (most common Phase III):
+  R --> Treatment A --> Outcome assessment
+  R --> Treatment B --> Outcome assessment
+
+Crossover:
+  R --> Treatment A --> Washout --> Treatment B --> Outcome
+  R --> Treatment B --> Washout --> Treatment A --> Outcome
+
+Factorial (2x2):
+  R --> Drug A + Drug B
+  R --> Drug A + Placebo B
+  R --> Placebo A + Drug B
+  R --> Placebo A + Placebo B
+
+Adaptive:
+  Stage 1: Enroll n1 patients --> Interim analysis
+  Stage 2: Modify design (dose, sample size, arm dropping) --> Continue
+```
+
+### Design Selection Criteria
+
+| Factor | Recommended Design |
+|--------|-------------------|
+| Chronic disease, stable condition | Crossover (within-subject comparison) |
+| Acute condition, one-time treatment | Parallel group |
+| Multiple drugs to evaluate | Factorial or multi-arm |
+| High uncertainty in effect size | Adaptive (sample size re-estimation) |
+| Rare disease, limited patients | Bayesian adaptive, single-arm with historical control |
+
+## Sample Size Calculation
+
+### Two-Sample Comparison of Means
+
+```python
+from scipy.stats import norm
+import numpy as np
+
+def sample_size_two_means(delta: float, sigma: float,
+                           alpha: float = 0.05, power: float = 0.80,
+                           ratio: float = 1.0) -> dict:
+    """
+    Sample size for comparing two group means (two-sided test).
+    delta: minimum clinically important difference
+    sigma: pooled standard deviation
+    alpha: type I error rate
+    power: desired power (1 - beta)
+    ratio: allocation ratio (n2/n1)
+    """
+    z_alpha = norm.ppf(1 - alpha / 2)
+    z_beta = norm.ppf(power)
+    effect = delta / sigma
+
+    n1 = ((z_alpha + z_beta) ** 2 * (1 + 1 / ratio)) / effect ** 2
+    n2 = ratio * n1
+
+    return {
+        "n_per_group_1": int(np.ceil(n1)),
+        "n_per_group_2": int(np.ceil(n2)),
+        "total": int(np.ceil(n1) + np.ceil(n2)),
+        "effect_size": round(effect, 3),
+    }
+
+# Example: detect 5-point difference, SD=15, 80% power
+result = sample_size_two_means(delta=5, sigma=15)
+print(f"Required: {result['total']} total patients")
+```
+
+### Sample Size for Survival Endpoints
+
+```python
+def sample_size_logrank(hazard_ratio: float, alpha: float = 0.05,
+                         power: float = 0.80, ratio: float = 1.0,
+                         median_control: float = 12.0,
+                         accrual_time: float = 24.0,
+                         followup_time: float = 12.0) -> dict:
+    """
+    Sample size for log-rank test comparing two survival curves.
+    hazard_ratio: expected HR (treatment/control), <1 means treatment better
+    median_control: median survival in control arm (months)
+    """
+    z_alpha = norm.ppf(1 - alpha / 2)
+    z_beta = norm.ppf(power)
+
+    # Required number of events (Schoenfeld formula)
+    d = ((z_alpha + z_beta) ** 2 * (1 + ratio) ** 2) / (
+        ratio * (np.log(hazard_ratio)) ** 2
+    )
+    d = int(np.ceil(d))
+
+    # Estimate probability of event during study
+    lambda_c = np.log(2) / median_control
+    lambda_t = lambda_c * hazard_ratio
+
+    # Average probability of event (simplified uniform accrual)
+    p_event_c = 1 - np.exp(-lambda_c * followup_time)
+    p_event_t = 1 - np.exp(-lambda_t * followup_time)
+    p_event_avg = (p_event_c + ratio * p_event_t) / (1 + ratio)
+
+    n_total = int(np.ceil(d / p_event_avg))
+
+    return {
+        "events_required": d,
+        "total_patients": n_total,
+        "hazard_ratio": hazard_ratio,
+        "p_event_avg": round(p_event_avg, 3),
+    }
+```
+
+## Randomization Methods
+
+### Implementation
+
+```python
+import random
+
+def stratified_block_randomization(strata: list[str],
+                                     block_sizes: list[int] = [4, 6],
+                                     ratio: tuple = (1, 1),
+                                     seed: int = 42) -> list[str]:
+    """
+    Stratified permuted block randomization.
+    strata: list of stratum labels for each patient (in enrollment order)
+    block_sizes: list of possible block sizes (randomly selected)
+    ratio: allocation ratio (e.g., (1,1) for 1:1, (2,1) for 2:1)
+    Returns list of treatment assignments ('A' or 'B').
+    """
+    rng = random.Random(seed)
+    stratum_queues = {}
+    assignments = []
+
+    for stratum in strata:
+        if stratum not in stratum_queues:
+            stratum_queues[stratum] = []
+
+        if not stratum_queues[stratum]:
+            # Generate new block
+            block_size = rng.choice(block_sizes)
+            n_a = block_size * ratio[0] // sum(ratio)
+            n_b = block_size - n_a
+            block = ["A"] * n_a + ["B"] * n_b
+            rng.shuffle(block)
+            stratum_queues[stratum] = block
+
+        assignments.append(stratum_queues[stratum].pop(0))
+
+    return assignments
+```
+
+## Interim Analysis and Monitoring
+
+### Group Sequential Design
+
+```python
+def obrien_fleming_boundary(n_looks: int, alpha: float = 0.05) -> list[float]:
+    """
+    Compute O'Brien-Fleming spending function boundaries.
+    Provides very conservative early stopping with near-nominal final alpha.
+    """
+    from scipy.stats import norm
+    boundaries = []
+    for k in range(1, n_looks + 1):
+        info_fraction = k / n_looks
+        z_boundary = norm.ppf(1 - alpha / 2) / np.sqrt(info_fraction)
+        p_boundary = 2 * (1 - norm.cdf(z_boundary))
+        boundaries.append({
+            "look": k,
+            "info_fraction": round(info_fraction, 3),
+            "z_boundary": round(z_boundary, 4),
+            "p_boundary": round(p_boundary, 6),
+        })
+    return boundaries
+
+# Example: 3 interim looks + 1 final
+boundaries = obrien_fleming_boundary(4)
+for b in boundaries:
+    print(f"Look {b['look']}: Z={b['z_boundary']}, p={b['p_boundary']}")
+```
+
+## Survival Analysis
+
+### Kaplan-Meier and Log-Rank Test
+
+```python
+from lifelines import KaplanMeierFitter
+from lifelines.statistics import logrank_test
+
+def analyze_survival(time: pd.Series, event: pd.Series,
+                      group: pd.Series) -> dict:
+    """
+    Perform Kaplan-Meier estimation and log-rank test.
+    time: follow-up duration
+    event: 1=event occurred, 0=censored
+    group: treatment group labels
+    """
+    groups = group.unique()
+    kmf_results = {}
+
+    for g in groups:
+        mask = group == g
+        kmf = KaplanMeierFitter()
+        kmf.fit(time[mask], event[mask], label=str(g))
+        kmf_results[g] = {
+            "median_survival": kmf.median_survival_time_,
+            "survival_at_12m": kmf.predict(12),
+        }
+
+    # Log-rank test
+    mask_a = group == groups[0]
+    lr = logrank_test(
+        time[mask_a], time[~mask_a],
+        event[mask_a], event[~mask_a],
+    )
+
+    return {
+        "group_results": kmf_results,
+        "logrank_statistic": lr.test_statistic,
+        "logrank_p_value": lr.p_value,
+    }
+```
+
+## Regulatory Considerations
+
+Key regulatory documents for clinical trial design:
+
+- **ICH E6 (R2)**: Good Clinical Practice guidelines
+- **ICH E9 (R1)**: Statistical Principles, estimands framework
+- **ICH E8 (R1)**: General Considerations for Clinical Studies
+- **FDA 21 CFR Part 312**: Investigational New Drug regulations
+- **EMA Scientific Guidelines**: Disease-specific guidance documents
+
+## Tools and Software
+
+- **R survival package**: Kaplan-Meier, Cox regression, log-rank test
+- **lifelines (Python)**: Survival analysis library
+- **gsDesign (R)**: Group sequential design and monitoring boundaries
+- **PASS / nQuery**: Commercial sample size software
+- **EAST (Cytel)**: Adaptive and group sequential design software
+- **REDCap**: Electronic data capture for clinical research
+- **ClinicalTrials.gov API**: Trial registry search and data access

package/skills/domains/pharma/drug-target-interaction/SKILL.md

@@ -0,0 +1,242 @@
+---
+name: drug-target-interaction
+description: "Computational drug-target interaction prediction and virtual screening"
+metadata:
+  openclaw:
+    emoji: "pill"
+    category: "domains"
+    subcategory: "pharma"
+    keywords: ["drug-target", "virtual-screening", "molecular-docking", "binding-affinity", "cheminformatics"]
+    source: "wentor"
+---
+
+# Drug-Target Interaction Prediction
+
+A skill for computational prediction of drug-target interactions (DTI), covering molecular docking, machine learning-based binding affinity prediction, compound library screening, and target identification using cheminformatics and structural biology tools.
+
+## Drug-Target Interaction Databases
+
+### Key Data Resources
+
+| Database | Content | Access |
+|----------|---------|--------|
+| ChEMBL | 2.4M compounds, 15M bioactivities | REST API, SQL dump |
+| BindingDB | 2.8M binding data points | Bulk download, REST API |
+| DrugBank | 15,000+ drug entries with targets | Academic license |
+| PDB (Protein Data Bank) | 220,000+ 3D structures | Free download, REST API |
+| UniProt | 250M+ protein sequences | Free, REST API |
+| STITCH | Chemical-protein interactions | Free academic access |
+
+### Fetching Bioactivity Data
+
+```python
+from chembl_webresource_client.new_client import new_client
+
+def get_target_bioactivities(target_chembl_id: str,
+                              activity_type: str = "IC50",
+                              max_nm: float = 10000) -> list[dict]:
+    """
+    Retrieve bioactivity data for a protein target from ChEMBL.
+    Returns compounds with measured binding/inhibition values.
+    """
+    activity = new_client.activity
+    results = activity.filter(
+        target_chembl_id=target_chembl_id,
+        standard_type=activity_type,
+        standard_relation="=",
+        standard_units="nM",
+    ).only([
+        "molecule_chembl_id", "canonical_smiles",
+        "standard_value", "standard_type",
+        "pchembl_value", "assay_description",
+    ])
+
+    filtered = []
+    for r in results:
+        if r.get("standard_value") and float(r["standard_value"]) <= max_nm:
+            filtered.append({
+                "molecule_id": r["molecule_chembl_id"],
+                "smiles": r["canonical_smiles"],
+                "activity_type": r["standard_type"],
+                "value_nM": float(r["standard_value"]),
+                "pchembl": float(r["pchembl_value"]) if r.get("pchembl_value") else None,
+            })
+    return filtered
+```
+
+## Molecular Fingerprints and Descriptors
+
+### Computing Molecular Representations
+
+```python
+from rdkit import Chem
+from rdkit.Chem import AllChem, Descriptors, rdMolDescriptors
+import numpy as np
+
+def compute_fingerprints(smiles_list: list[str],
+                          fp_type: str = "morgan",
+                          radius: int = 2,
+                          n_bits: int = 2048) -> np.ndarray:
+    """
+    Compute molecular fingerprints from SMILES strings.
+    fp_type: 'morgan' (ECFP-like), 'maccs', 'rdkit', 'topological'
+    """
+    fps = []
+    for smi in smiles_list:
+        mol = Chem.MolFromSmiles(smi)
+        if mol is None:
+            fps.append(np.zeros(n_bits))
+            continue
+
+        if fp_type == "morgan":
+            fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius, nBits=n_bits)
+        elif fp_type == "maccs":
+            fp = rdMolDescriptors.GetMACCSKeysFingerprint(mol)
+        elif fp_type == "rdkit":
+            fp = Chem.RDKFingerprint(mol, fpSize=n_bits)
+        else:
+            fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius, nBits=n_bits)
+
+        arr = np.zeros(len(fp))
+        Chem.DataStructs.ConvertToNumpyArray(fp, arr)
+        fps.append(arr)
+
+    return np.array(fps)
+
+def compute_descriptors(smiles: str) -> dict:
+    """Compute physicochemical descriptors for a molecule."""
+    mol = Chem.MolFromSmiles(smiles)
+    if mol is None:
+        return {}
+    return {
+        "molecular_weight": Descriptors.MolWt(mol),
+        "logP": Descriptors.MolLogP(mol),
+        "hbd": Descriptors.NumHDonors(mol),
+        "hba": Descriptors.NumHAcceptors(mol),
+        "tpsa": Descriptors.TPSA(mol),
+        "rotatable_bonds": Descriptors.NumRotatableBonds(mol),
+        "aromatic_rings": Descriptors.NumAromaticRings(mol),
+        "lipinski_violations": sum([
+            Descriptors.MolWt(mol) > 500,
+            Descriptors.MolLogP(mol) > 5,
+            Descriptors.NumHDonors(mol) > 5,
+            Descriptors.NumHAcceptors(mol) > 10,
+        ]),
+    }
+```
+
+## Machine Learning for DTI Prediction
+
+### Binary Classification Model
+
+```python
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import StratifiedKFold
+from sklearn.metrics import roc_auc_score, average_precision_score
+
+def train_dti_classifier(compound_fps: np.ndarray,
+                          target_features: np.ndarray,
+                          labels: np.ndarray) -> dict:
+    """
+    Train a DTI classifier using compound-target pair features.
+    compound_fps: molecular fingerprints (n_samples, fp_dim)
+    target_features: protein descriptors (n_samples, target_dim)
+    labels: binary interaction labels (1=interacts, 0=no interaction)
+    """
+    # Concatenate compound and target features
+    X = np.hstack([compound_fps, target_features])
+    y = labels
+
+    skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
+    metrics = {"auroc": [], "auprc": []}
+
+    for train_idx, test_idx in skf.split(X, y):
+        model = RandomForestClassifier(
+            n_estimators=500, max_depth=20, n_jobs=-1, random_state=42
+        )
+        model.fit(X[train_idx], y[train_idx])
+        pred_proba = model.predict_proba(X[test_idx])[:, 1]
+
+        metrics["auroc"].append(roc_auc_score(y[test_idx], pred_proba))
+        metrics["auprc"].append(average_precision_score(y[test_idx], pred_proba))
+
+    return {
+        "mean_auroc": np.mean(metrics["auroc"]),
+        "mean_auprc": np.mean(metrics["auprc"]),
+        "model": model,
+    }
+```
+
+### Deep Learning Approaches
+
+Modern DTI prediction architectures:
+
+| Method | Compound Representation | Target Representation | Architecture |
+|--------|------------------------|----------------------|-------------|
+| DeepDTA | SMILES (1D CNN) | Protein sequence (1D CNN) | Concatenation + FC |
+| GraphDTA | Molecular graph (GCN/GAT) | Protein sequence (CNN) | Graph + sequence fusion |
+| MolTrans | SMILES (Transformer) | Protein sequence (Transformer) | Cross-attention |
+| DrugBAN | Molecular graph | Protein graph | Bilinear attention |
+
+## Molecular Docking
+
+### Structure-Based Virtual Screening
+
+```python
+import subprocess
+
+def run_autodock_vina(receptor_pdbqt: str, ligand_pdbqt: str,
+                      center: tuple, box_size: tuple = (20, 20, 20),
+                      exhaustiveness: int = 8) -> dict:
+    """
+    Run AutoDock Vina for molecular docking.
+    receptor_pdbqt: path to prepared receptor file
+    ligand_pdbqt: path to prepared ligand file
+    center: (x, y, z) coordinates of the binding site center
+    Returns docking scores and poses.
+    """
+    cmd = [
+        "vina",
+        "--receptor", receptor_pdbqt,
+        "--ligand", ligand_pdbqt,
+        "--center_x", str(center[0]),
+        "--center_y", str(center[1]),
+        "--center_z", str(center[2]),
+        "--size_x", str(box_size[0]),
+        "--size_y", str(box_size[1]),
+        "--size_z", str(box_size[2]),
+        "--exhaustiveness", str(exhaustiveness),
+        "--num_modes", "9",
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    # Parse output for binding affinities
+    scores = []
+    for line in result.stdout.split("\n"):
+        parts = line.split()
+        if len(parts) >= 4 and parts[0].isdigit():
+            scores.append({
+                "mode": int(parts[0]),
+                "affinity_kcal_mol": float(parts[1]),
+                "rmsd_lb": float(parts[2]),
+                "rmsd_ub": float(parts[3]),
+            })
+    return {"scores": scores, "best_affinity": scores[0]["affinity_kcal_mol"] if scores else None}
+```
+
+## Validation and Benchmarking
+
+Standard benchmarks for DTI prediction:
+
+- **DUD-E**: Directory of Useful Decoys, Enhanced (102 targets, 22,886 actives)
+- **MUV**: Maximum Unbiased Validation datasets (17 targets)
+- **LIT-PCBA**: Large-scale confirmatory bioassay benchmark
+- **Davis and KIBA**: Kinase binding affinity datasets for regression
+
+## Tools and Libraries
+
+- **RDKit**: Open-source cheminformatics toolkit
+- **AutoDock Vina / Smina**: Molecular docking engines
+- **OpenMM**: GPU-accelerated molecular dynamics
+- **DeepChem**: Deep learning for drug discovery
+- **PyMOL / ChimeraX**: Molecular visualization
+- **Open Babel**: Chemical file format conversion

package/skills/domains/pharma/madd-drug-discovery-guide/SKILL.md

@@ -0,0 +1,153 @@
+---
+name: madd-drug-discovery-guide
+description: "Multi-agent system for automated drug discovery pipelines"
+metadata:
+  openclaw:
+    emoji: "💊"
+    category: "domains"
+    subcategory: "pharma"
+    keywords: ["drug discovery", "multi-agent", "molecular design", "ADMET", "virtual screening", "pharma AI"]
+    source: "https://github.com/sb-ai-lab/MADD"
+---
+
+# MADD: Multi-Agent Drug Discovery Guide
+
+## Overview
+
+MADD (Multi-Agent Drug Discovery) is a multi-agent system that automates key stages of the drug discovery pipeline — target identification, molecule generation, property prediction (ADMET), docking simulation, and lead optimization. Specialized agents collaborate to propose, evaluate, and refine drug candidates, reducing the manual effort in early-stage drug discovery research.
+
+## Agent Pipeline
+
+```
+Target Protein
+      ↓
+  Target Analysis Agent (binding site, druggability)
+      ↓
+  Molecule Generation Agent (de novo design)
+      ↓
+  Property Prediction Agent (ADMET screening)
+      ↓
+  Docking Agent (binding affinity estimation)
+      ↓
+  Optimization Agent (lead optimization cycle)
+      ↓
+  Report Agent (candidate ranking + rationale)
+```
+
+## Usage
+
+```python
+from madd import DrugDiscoveryPipeline
+
+pipeline = DrugDiscoveryPipeline(
+    llm_provider="anthropic",
+    tools=["rdkit", "autodock_vina", "admet_predictor"],
+)
+
+# Run discovery pipeline
+results = pipeline.discover(
+    target_protein="6LU7",  # PDB ID (SARS-CoV-2 Mpro)
+    target_site="active_site",
+    constraints={
+        "molecular_weight": (200, 500),    # Lipinski
+        "logP": (-0.4, 5.6),
+        "hbd": (0, 5),
+        "hba": (0, 10),
+        "tpsa": (0, 140),
+    },
+    num_candidates=100,
+    optimization_rounds=3,
+)
+
+# Top candidates
+for i, mol in enumerate(results.top_candidates[:5]):
+    print(f"\nCandidate {i+1}: {mol.smiles}")
+    print(f"  Docking score: {mol.docking_score:.2f} kcal/mol")
+    print(f"  QED: {mol.qed:.3f}")
+    print(f"  Synthetic accessibility: {mol.sa_score:.2f}")
+    print(f"  ADMET: {mol.admet_summary}")
+```
+
+## ADMET Prediction
+
+```python
+from madd.agents import ADMETAgent
+
+admet = ADMETAgent()
+
+# Predict ADMET properties for a molecule
+props = admet.predict("CC(=O)Oc1ccccc1C(=O)O")  # Aspirin
+
+print(f"Absorption: {props.absorption}")
+print(f"Distribution: {props.distribution}")
+print(f"Metabolism: {props.metabolism}")
+print(f"Excretion: {props.excretion}")
+print(f"Toxicity: {props.toxicity}")
+print(f"BBB penetration: {props.bbb_penetration}")
+print(f"CYP inhibition: {props.cyp_inhibition}")
+print(f"hERG liability: {props.herg_risk}")
+```
+
+## Molecule Generation
+
+```python
+from madd.agents import MolGenAgent
+
+gen = MolGenAgent(method="reinforcement_learning")
+
+# Generate molecules targeting a binding site
+molecules = gen.generate(
+    target_pdb="6LU7",
+    binding_site="active_site",
+    num_molecules=500,
+    diversity_threshold=0.5,  # Tanimoto diversity
+    constraints={
+        "drug_likeness": True,  # Lipinski + Veber
+        "novelty": True,        # Not in ChEMBL
+    },
+)
+
+print(f"Generated: {len(molecules)}")
+print(f"Drug-like: {sum(1 for m in molecules if m.is_drug_like)}")
+print(f"Novel: {sum(1 for m in molecules if m.is_novel)}")
+```
+
+## Lead Optimization
+
+```python
+from madd.agents import OptimizationAgent
+
+optimizer = OptimizationAgent()
+
+# Optimize a lead compound
+optimized = optimizer.optimize(
+    lead_smiles="c1ccc(-c2ncc(F)c(N)n2)cc1",
+    objectives=[
+        ("docking_score", "minimize"),
+        ("qed", "maximize"),
+        ("sa_score", "minimize"),
+        ("solubility", "maximize"),
+    ],
+    num_iterations=50,
+    keep_scaffold=True,  # Maintain core structure
+)
+
+for mol in optimized.pareto_front[:5]:
+    print(f"SMILES: {mol.smiles}")
+    print(f"  Docking: {mol.docking_score:.2f}")
+    print(f"  QED: {mol.qed:.3f}")
+```
+
+## Use Cases
+
+1. **Hit discovery**: Generate novel drug candidates for targets
+2. **Lead optimization**: Improve properties of promising compounds
+3. **ADMET screening**: Predict pharmacokinetic properties
+4. **Virtual screening**: Score large molecule libraries
+5. **Drug repurposing**: Evaluate known drugs for new targets
+
+## References
+
+- [MADD GitHub](https://github.com/sb-ai-lab/MADD)
+- [RDKit](https://www.rdkit.org/) — Chemistry toolkit
+- [AutoDock Vina](https://vina.scripps.edu/) — Molecular docking