@bgicli/bgicli 2.1.1 → 2.2.0

package/data/skills/patents-search/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: patents-search
+description: Search global patents with natural language queries. Prior art, patent landscapes, and innovation tracking via Valyu.
+keywords:
+  - patents
+  - patent-search
+  - prior-art
+  - intellectual-property
+  - innovation-tracking
+  - semantic-search
+license: MIT
+---
+
+
+# Patents Search
+
+Search the complete global patent database using natural language queries powered by Valyu's semantic search API.
+
+## Why This Skill is Powerful
+
+- **No API Parameter Parsing**: Just pass natural language queries directly - no need to construct complex search parameters
+- **Semantic Search**: Understands the meaning of your query, not just keyword matching
+- **Full-Text Access**: Returns complete patent information including claims, descriptions, and technical details
+- **Image Links**: Includes patent diagrams and figures when available
+- **Comprehensive Coverage**: Access to global patent data across jurisdictions
+
+## Requirements
+
+1. Node.js 18+ (uses built-in fetch)
+2. Valyu API key from https://platform.valyu.ai ($10 free credits)
+
+## CRITICAL: Script Path Resolution
+
+The `scripts/search` commands in this documentation are relative to this skill's installation directory.
+
+Before running any command, locate the script using:
+
+```bash
+PATENTS_SCRIPT=$(find ~/.claude/plugins/cache -name "search" -path "*/patents-search/*/scripts/*" -type f 2>/dev/null | head -1)
+```
+
+Then use the full path for all commands:
+```bash
+$PATENTS_SCRIPT "CRISPR gene editing methods" 15
+```
+
+## API Key Setup Flow
+
+When you run a search and receive `"setup_required": true`, follow this flow:
+
+1. **Ask the user for their API key:**
+   "To search patents, I need your Valyu API key. Get one free ($10 credits) at https://platform.valyu.ai"
+
+2. **Once the user provides the key, run:**
+   ```bash
+   scripts/search setup <api-key>
+   ```
+
+3. **Retry the original search.**
+
+## When to Use This Skill
+
+- Prior art searching and patent landscaping
+- Technology trend analysis
+- Competitor innovation tracking
+- Patent freedom-to-operate analysis
+- Patent claim analysis and interpretation
+- Patent filing strategy research
+## Output Format
+
+```json
+{
+  "success": true,
+  "type": "patents_search",
+  "query": "CRISPR gene editing methods",
+  "result_count": 10,
+  "results": [
+    {
+      "title": "Patent Title",
+      "url": "https://patents.google.com/...",
+      "content": "Patent claims, description, technical details...",
+      "source": "patents",
+      "relevance_score": 0.95,
+      "images": ["https://example.com/diagram.png"]
+    }
+  ],
+  "cost": 0.025
+}
+```
+
+## Processing Results
+
+### With jq
+
+```bash
+# Get patent titles
+scripts/search "query" 10 | jq -r '.results[].title'
+
+# Get URLs
+scripts/search "query" 10 | jq -r '.results[].url'
+
+# Extract full content
+scripts/search "query" 10 | jq -r '.results[].content'
+```
+
+## Common Use Cases
+
+### Prior Art Search
+
+```bash
+# Find prior art
+scripts/search "lithium ion battery electrode materials" 50
+```
+
+### Competitive Intelligence
+
+```bash
+# Search competitor patents
+scripts/search "CAR-T cell therapy manufacturing methods" 20
+```
+
+### Technology Landscape
+
+```bash
+# Find technology trends
+scripts/search "quantum computing error correction patents" 15
+```
+
+### Freedom to Operate
+
+```bash
+# Search for blocking patents
+scripts/search "mRNA vaccine delivery systems" 25
+```
+
+
+## Error Handling
+
+All commands return JSON with `success` field:
+
+```json
+{
+  "success": false,
+  "error": "Error message"
+}
+```
+
+Exit codes:
+- `0` - Success
+- `1` - Error (check JSON for details)
+
+## API Endpoint
+
+- Base URL: `https://api.valyu.ai/v1`
+- Endpoint: `/search`
+- Authentication: X-API-Key header
+
+## Architecture
+
+```
+scripts/
+├── search          # Bash wrapper
+└── search.mjs      # Node.js CLI
+```
+
+Direct API calls using Node.js built-in `fetch()`, zero external dependencies.
+
+## Adding to Your Project
+
+If you're building an AI project and want to integrate Patents Search directly into your application, use the Valyu SDK:
+
+### Python Integration
+
+```python
+from valyu import Valyu
+
+client = Valyu(api_key="your-api-key")
+
+response = client.search(
+    query="your search query here",
+    included_sources=["valyu/valyu-patents"],
+    max_results=20
+)
+
+for result in response["results"]:
+    print(f"Title: {result['title']}")
+    print(f"URL: {result['url']}")
+    print(f"Content: {result['content'][:500]}...")
+```
+
+### TypeScript Integration
+
+```typescript
+import { Valyu } from "valyu-js";
+
+const client = new Valyu("your-api-key");
+
+const response = await client.search({
+  query: "your search query here",
+  includedSources: ["valyu/valyu-patents"],
+  maxResults: 20
+});
+
+response.results.forEach((result) => {
+  console.log(`Title: ${result.title}`);
+  console.log(`URL: ${result.url}`);
+  console.log(`Content: ${result.content.substring(0, 500)}...`);
+});
+```
+
+See the [Valyu docs](https://docs.valyu.ai) for full integration examples and SDK reference.

package/data/skills/pathml/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: pathml
+description: Computational pathology toolkit for analyzing whole-slide images (WSI) and multiparametric imaging data. Use this skill when working with histopathology slides, H&E stained images, multiplex immunofluorescence (CODEX, Vectra), spatial proteomics, nucleus detection/segmentation, tissue graph construction, or training ML models on pathology data. Supports 160+ slide formats including Aperio SVS, NDPI, DICOM, OME-TIFF for digital pathology workflows.
+---
+
+# PathML
+
+## Overview
+
+PathML is a comprehensive Python toolkit for computational pathology workflows, designed to facilitate machine learning and image analysis for whole-slide pathology images. The framework provides modular, composable tools for loading diverse slide formats, preprocessing images, constructing spatial graphs, training deep learning models, and analyzing multiparametric imaging data from technologies like CODEX and multiplex immunofluorescence.
+
+## When to Use This Skill
+
+Apply this skill for:
+- Loading and processing whole-slide images (WSI) in various proprietary formats
+- Preprocessing H&E stained tissue images with stain normalization
+- Nucleus detection, segmentation, and classification workflows
+- Building cell and tissue graphs for spatial analysis
+- Training or deploying machine learning models (HoVer-Net, HACTNet) on pathology data
+- Analyzing multiparametric imaging (CODEX, Vectra, MERFISH) for spatial proteomics
+- Quantifying marker expression from multiplex immunofluorescence
+- Managing large-scale pathology datasets with HDF5 storage
+- Tile-based analysis and stitching operations
+
+## Core Capabilities
+
+PathML provides six major capability areas documented in detail within reference files:
+
+### 1. Image Loading & Formats
+
+Load whole-slide images from 160+ proprietary formats including Aperio SVS, Hamamatsu NDPI, Leica SCN, Zeiss ZVI, DICOM, and OME-TIFF. PathML automatically handles vendor-specific formats and provides unified interfaces for accessing image pyramids, metadata, and regions of interest.
+
+**See:** `references/image_loading.md` for supported formats, loading strategies, and working with different slide types.
+
+### 2. Preprocessing Pipelines
+
+Build modular preprocessing pipelines by composing transforms for image manipulation, quality control, stain normalization, tissue detection, and mask operations. PathML's Pipeline architecture enables reproducible, scalable preprocessing across large datasets.
+
+**Key transforms:**
+- `StainNormalizationHE` - Macenko/Vahadane stain normalization
+- `TissueDetectionHE`, `NucleusDetectionHE` - Tissue/nucleus segmentation
+- `MedianBlur`, `GaussianBlur` - Noise reduction
+- `LabelArtifactTileHE` - Quality control for artifacts
+
+**See:** `references/preprocessing.md` for complete transform catalog, pipeline construction, and preprocessing workflows.
+
+### 3. Graph Construction
+
+Construct spatial graphs representing cellular and tissue-level relationships. Extract features from segmented objects to create graph-based representations suitable for graph neural networks and spatial analysis.
+
+**See:** `references/graphs.md` for graph construction methods, feature extraction, and spatial analysis workflows.
+
+### 4. Machine Learning
+
+Train and deploy deep learning models for nucleus detection, segmentation, and classification. PathML integrates PyTorch with pre-built models (HoVer-Net, HACTNet), custom DataLoaders, and ONNX support for inference.
+
+**Key models:**
+- **HoVer-Net** - Simultaneous nucleus segmentation and classification
+- **HACTNet** - Hierarchical cell-type classification
+
+**See:** `references/machine_learning.md` for model training, evaluation, inference workflows, and working with public datasets.
+
+### 5. Multiparametric Imaging
+
+Analyze spatial proteomics and gene expression data from CODEX, Vectra, MERFISH, and other multiplex imaging platforms. PathML provides specialized slide classes and transforms for processing multiparametric data, cell segmentation with Mesmer, and quantification workflows.
+
+**See:** `references/multiparametric.md` for CODEX/Vectra workflows, cell segmentation, marker quantification, and integration with AnnData.
+
+### 6. Data Management
+
+Efficiently store and manage large pathology datasets using HDF5 format. PathML handles tiles, masks, metadata, and extracted features in unified storage structures optimized for machine learning workflows.
+
+**See:** `references/data_management.md` for HDF5 integration, tile management, dataset organization, and batch processing strategies.
+
+## Quick Start
+
+### Installation
+
+```bash
+# Install PathML
+uv pip install pathml
+
+# With optional dependencies for all features
+uv pip install pathml[all]
+```
+
+### Basic Workflow Example
+
+```python
+from pathml.core import SlideData
+from pathml.preprocessing import Pipeline, StainNormalizationHE, TissueDetectionHE
+
+# Load a whole-slide image
+wsi = SlideData.from_slide("path/to/slide.svs")
+
+# Create preprocessing pipeline
+pipeline = Pipeline([
+    TissueDetectionHE(),
+    StainNormalizationHE(target='normalize', stain_estimation_method='macenko')
+])
+
+# Run pipeline
+pipeline.run(wsi)
+
+# Access processed tiles
+for tile in wsi.tiles:
+    processed_image = tile.image
+    tissue_mask = tile.masks['tissue']
+```
+
+### Common Workflows
+
+**H&E Image Analysis:**
+1. Load WSI with appropriate slide class
+2. Apply tissue detection and stain normalization
+3. Perform nucleus detection or train segmentation models
+4. Extract features and build spatial graphs
+5. Conduct downstream analysis
+
+**Multiparametric Imaging (CODEX):**
+1. Load CODEX slide with `CODEXSlide`
+2. Collapse multi-run channel data
+3. Segment cells using Mesmer model
+4. Quantify marker expression
+5. Export to AnnData for single-cell analysis
+
+**Training ML Models:**
+1. Prepare dataset with public pathology data
+2. Create PyTorch DataLoader with PathML datasets
+3. Train HoVer-Net or custom models
+4. Evaluate on held-out test sets
+5. Deploy with ONNX for inference
+
+## References to Detailed Documentation
+
+When working on specific tasks, refer to the appropriate reference file for comprehensive information:
+
+- **Loading images:** `references/image_loading.md`
+- **Preprocessing workflows:** `references/preprocessing.md`
+- **Spatial analysis:** `references/graphs.md`
+- **Model training:** `references/machine_learning.md`
+- **CODEX/multiplex IF:** `references/multiparametric.md`
+- **Data storage:** `references/data_management.md`
+
+## Resources
+
+This skill includes comprehensive reference documentation organized by capability area. Each reference file contains detailed API information, workflow examples, best practices, and troubleshooting guidance for specific PathML functionality.
+
+### references/
+
+Documentation files providing in-depth coverage of PathML capabilities:
+
+- `image_loading.md` - Whole-slide image formats, loading strategies, slide classes
+- `preprocessing.md` - Complete transform catalog, pipeline construction, preprocessing workflows
+- `graphs.md` - Graph construction methods, feature extraction, spatial analysis
+- `machine_learning.md` - Model architectures, training workflows, evaluation, inference
+- `multiparametric.md` - CODEX, Vectra, multiplex IF analysis, cell segmentation, quantification
+- `data_management.md` - HDF5 storage, tile management, batch processing, dataset organization
+
+Load these references as needed when working on specific computational pathology tasks.

package/data/skills/patiently-ai/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: patiently-ai
+description: Patiently AI simplifies medical documents for patients. Takes doctor's letters, test results, prescriptions, discharge summaries, and clinical notes and explains them in clear, personalised language. Built by PharmaTools.AI.
+metadata:
+  {
+    "openclaw":
+      {
+        "emoji": "🩺",
+        "homepage": "https://pharmatools.ai",
+      },
+  }
+---
+
+# Patiently AI
+
+Patiently AI simplifies medical documents for patients. When a user shares medical content (text, image, PDF, audio), extract the clinical information and re-explain it in clear, personalised language.
+
+## Accepted Input
+
+- Doctor's letters and clinic notes
+- Blood test results and lab reports
+- Prescriptions and medication info
+- Discharge summaries
+- Photos of medical documents
+- Audio recordings of doctor consultations
+- PDFs and Word files with medical content
+
+## Core Rules
+
+Follow these strictly:
+
+1. **Reflect what the document says. Do not interpret it.**
+2. Do not add medical judgement, diagnoses, risk assessment, or advice.
+3. Do not infer details that are not explicitly stated.
+4. If something is unclear, say it is unclear.
+5. Preserve uncertainty rather than resolving it.
+6. Use cautious, neutral phrasing.
+7. Do not introduce causal reasoning.
+8. Do not assess, exclude, prioritise, or down-rank possible causes.
+9. Do not describe attempted explanations or hypotheses as evidence.
+10. Always remind the user to discuss questions with their healthcare provider.
+
+## Personalisation
+
+Before simplifying, ask the user (or use defaults if they specify):
+
+**Reading level:**
+- Child (ages 6–12) — very simple words, short sentences, reassuring
+- Teen (ages 13–17) — clear and direct, no jargon
+- Adult (default) — plain language, assumes basic health literacy
+- Carer — slightly more detailed, practical focus on what to do
+
+**Tone:**
+- Friendly — warm, conversational
+- Reassuring — calm, supportive, acknowledges worry
+- Informative (default) — neutral, factual, clear
+
+**Length:**
+- Brief — key points only, 2–3 paragraphs
+- Standard (default) — covers all main points clearly
+- Detailed — thorough section-by-section breakdown
+
+**Language:** English (default), Spanish, French, German, Italian, Portuguese, Polish, Russian, Arabic, Chinese, Hindi, Vietnamese.
+
+## Output Structure
+
+1. **Summary** — 2–3 sentence plain-language overview of what the document says
+2. **Section breakdown** — go through each part of the document and explain it
+3. **Medical terms** — define any medical terms used, in plain language
+4. **Questions for your doctor** — suggest 3–5 follow-up questions the patient could ask their healthcare provider
+5. **Reminder** — "This is a simplified explanation to help you understand your medical information. Always discuss your care with your healthcare provider."
+
+## Examples
+
+**User:** "Can you explain this blood test?" [attaches image]
+
+**Response pattern:**
+- Extract values from the image
+- Summarise: "Your blood test looked at X, Y, and Z..."
+- Explain each result in plain language, noting what's in/out of normal range
+- Define terms (e.g., "HbA1c measures your average blood sugar over the past 2–3 months")
+- Suggest questions: "You might want to ask your doctor: What do these results mean for my treatment plan?"
+
+**User:** "My mum got this letter from the hospital, she doesn't understand it" [pastes text]
+
+**Response pattern:**
+- Detect carer context, adjust tone
+- Summarise the letter's purpose
+- Break down each section
+- Flag any action items (appointments, medications)
+- Suggest questions the carer could ask on behalf of the patient
+
+## What This Skill Does NOT Do
+
+- Provide diagnoses or differential diagnoses
+- Recommend treatments or medications
+- Contradict or second-guess the treating clinician
+- Triage symptoms or assess urgency
+- Replace professional medical advice
+
+---
+
+Built by [PharmaTools.AI](https://pharmatools.ai) — applied AI for pharma and healthcare.

package/data/skills/pdb/SKILL.md

@@ -0,0 +1,217 @@
+---
+name: pdb
+description: >
+  Fetch and analyze protein structures from RCSB PDB. Use this skill when:
+  (1) Need to download a structure by PDB ID,
+  (2) Search for similar structures,
+  (3) Prepare target for binder design,
+  (4) Extract specific chains or domains,
+  (5) Get structure metadata.
+
+  For sequence lookup, use uniprot.
+  For binder design workflow, use binder-design.
+license: MIT
+category: utilities
+tags: [database, structure, fetch]
+---
+
+# PDB Database Access
+
+**Note**: This skill uses the RCSB PDB web API directly. No Modal deployment needed - all operations run locally via HTTP requests.
+
+## Fetching Structures
+
+### By PDB ID
+```bash
+# Download PDB file
+curl -o 1alu.pdb "https://files.rcsb.org/download/1ALU.pdb"
+
+# Download mmCIF
+curl -o 1alu.cif "https://files.rcsb.org/download/1ALU.cif"
+```
+
+### Using Python
+```python
+from Bio.PDB import PDBList
+
+pdbl = PDBList()
+pdbl.retrieve_pdb_file("1ABC", pdir="structures/", file_format="pdb")
+```
+
+### Using RCSB API
+```python
+import requests
+
+def fetch_pdb(pdb_id: str, format: str = "pdb") -> str:
+    """Fetch structure from RCSB PDB."""
+    url = f"https://files.rcsb.org/download/{pdb_id}.{format}"
+    response = requests.get(url)
+    response.raise_for_status()
+    return response.text
+
+def fetch_fasta(pdb_id: str) -> str:
+    """Fetch sequence in FASTA format."""
+    url = f"https://www.rcsb.org/fasta/entry/{pdb_id}"
+    return requests.get(url).text
+
+# Example usage
+pdb_content = fetch_pdb("1ALU")
+with open("1ALU.pdb", "w") as f:
+    f.write(pdb_content)
+```
+
+## Structure Preparation
+
+### Selecting Chains
+```python
+from Bio.PDB import PDBParser, PDBIO, Select
+
+class ChainSelect(Select):
+    def __init__(self, chain_id):
+        self.chain_id = chain_id
+
+    def accept_chain(self, chain):
+        return chain.id == self.chain_id
+
+# Extract chain A
+parser = PDBParser()
+structure = parser.get_structure("protein", "1abc.pdb")
+io = PDBIO()
+io.set_structure(structure)
+io.save("chain_A.pdb", ChainSelect("A"))
+```
+
+### Trimming to Binding Region
+```python
+def trim_around_residues(pdb_file, center_residues, buffer=10.0):
+    """Trim structure to region around specified residues."""
+    parser = PDBParser()
+    structure = parser.get_structure("protein", pdb_file)
+
+    # Get center coordinates
+    center_coords = []
+    for res in structure.get_residues():
+        if res.id[1] in center_residues:
+            center_coords.extend([a.coord for a in res.get_atoms()])
+
+    center = np.mean(center_coords, axis=0)
+
+    # Keep residues within buffer
+    class RegionSelect(Select):
+        def accept_residue(self, res):
+            for atom in res.get_atoms():
+                if np.linalg.norm(atom.coord - center) < buffer:
+                    return True
+            return False
+
+    io = PDBIO()
+    io.set_structure(structure)
+    io.save("trimmed.pdb", RegionSelect())
+```
+
+## Searching PDB
+
+### RCSB Search API
+```python
+import requests
+
+query = {
+    "query": {
+        "type": "terminal",
+        "service": "full_text",
+        "parameters": {
+            "value": "EGFR kinase domain"
+        }
+    },
+    "return_type": "entry"
+}
+
+response = requests.post(
+    "https://search.rcsb.org/rcsbsearch/v2/query",
+    json=query
+)
+results = response.json()
+```
+
+### By Sequence Similarity
+```python
+query = {
+    "query": {
+        "type": "terminal",
+        "service": "sequence",
+        "parameters": {
+            "value": "MKTAYIAKQRQISFVK...",
+            "evalue_cutoff": 1e-10,
+            "identity_cutoff": 0.9
+        }
+    }
+}
+```
+
+## Structure Analysis
+
+### Get Chain Info
+```python
+def get_structure_info(pdb_file):
+    parser = PDBParser(QUIET=True)
+    structure = parser.get_structure("protein", pdb_file)
+
+    info = {
+        "chains": [],
+        "total_residues": 0
+    }
+
+    for model in structure:
+        for chain in model:
+            residues = list(chain.get_residues())
+            info["chains"].append({
+                "id": chain.id,
+                "length": len(residues),
+                "first_res": residues[0].id[1],
+                "last_res": residues[-1].id[1]
+            })
+            info["total_residues"] += len(residues)
+
+    return info
+```
+
+### Find Interface Residues
+```python
+def find_interface_residues(pdb_file, chain_a, chain_b, distance=4.0):
+    """Find residues at interface between two chains."""
+    parser = PDBParser(QUIET=True)
+    structure = parser.get_structure("complex", pdb_file)
+
+    interface_a = set()
+    interface_b = set()
+
+    for res_a in structure[0][chain_a].get_residues():
+        for res_b in structure[0][chain_b].get_residues():
+            for atom_a in res_a.get_atoms():
+                for atom_b in res_b.get_atoms():
+                    if atom_a - atom_b < distance:
+                        interface_a.add(res_a.id[1])
+                        interface_b.add(res_b.id[1])
+
+    return interface_a, interface_b
+```
+
+## Common Tasks for Binder Design
+
+### Target Preparation Checklist
+1. Download structure: `curl -o target.pdb "https://files.rcsb.org/download/XXXX.pdb"`
+2. Identify target chain
+3. Remove waters and ligands (if needed)
+4. Trim to binding region + buffer
+5. Identify potential hotspots
+6. Renumber if needed
+
+## Troubleshooting
+
+**Structure not found**: Check PDB ID format (4 characters)
+**Multiple models**: Select first model for design
+**Missing residues**: Check for gaps in structure
+
+---
+
+**Next**: Use structure with `boltzgen` (recommended) or `rfdiffusion` for design.