@bgicli/bgicli 2.1.1 → 2.2.0

package/data/skills/docx-official/SKILL.md

@@ -0,0 +1,197 @@
+---
+name: docx
+description: "Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks"
+license: Proprietary. LICENSE.txt has complete terms
+---
+
+# DOCX creation, editing, and analysis
+
+## Overview
+
+A user may ask you to create, edit, or analyze the contents of a .docx file. A .docx file is essentially a ZIP archive containing XML files and other resources that you can read or edit. You have different tools and workflows available for different tasks.
+
+## Workflow Decision Tree
+
+### Reading/Analyzing Content
+Use "Text extraction" or "Raw XML access" sections below
+
+### Creating New Document
+Use "Creating a new Word document" workflow
+
+### Editing Existing Document
+- **Your own document + simple changes**
+  Use "Basic OOXML editing" workflow
+
+- **Someone else's document**
+  Use **"Redlining workflow"** (recommended default)
+
+- **Legal, academic, business, or government docs**
+  Use **"Redlining workflow"** (required)
+
+## Reading and analyzing content
+
+### Text extraction
+If you just need to read the text contents of a document, you should convert the document to markdown using pandoc. Pandoc provides excellent support for preserving document structure and can show tracked changes:
+
+```bash
+# Convert document to markdown with tracked changes
+pandoc --track-changes=all path-to-file.docx -o output.md
+# Options: --track-changes=accept/reject/all
+```
+
+### Raw XML access
+You need raw XML access for: comments, complex formatting, document structure, embedded media, and metadata. For any of these features, you'll need to unpack a document and read its raw XML contents.
+
+#### Unpacking a file
+`python ooxml/scripts/unpack.py <office_file> <output_directory>`
+
+#### Key file structures
+* `word/document.xml` - Main document contents
+* `word/comments.xml` - Comments referenced in document.xml
+* `word/media/` - Embedded images and media files
+* Tracked changes use `<w:ins>` (insertions) and `<w:del>` (deletions) tags
+
+## Creating a new Word document
+
+When creating a new Word document from scratch, use **docx-js**, which allows you to create Word documents using JavaScript/TypeScript.
+
+### Workflow
+1. **MANDATORY - READ ENTIRE FILE**: Read [`docx-js.md`](docx-js.md) (~500 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for detailed syntax, critical formatting rules, and best practices before proceeding with document creation.
+2. Create a JavaScript/TypeScript file using Document, Paragraph, TextRun components (You can assume all dependencies are installed, but if not, refer to the dependencies section below)
+3. Export as .docx using Packer.toBuffer()
+
+## Editing an existing Word document
+
+When editing an existing Word document, use the **Document library** (a Python library for OOXML manipulation). The library automatically handles infrastructure setup and provides methods for document manipulation. For complex scenarios, you can access the underlying DOM directly through the library.
+
+### Workflow
+1. **MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~600 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Read the full file content for the Document library API and XML patterns for directly editing document files.
+2. Unpack the document: `python ooxml/scripts/unpack.py <office_file> <output_directory>`
+3. Create and run a Python script using the Document library (see "Document Library" section in ooxml.md)
+4. Pack the final document: `python ooxml/scripts/pack.py <input_directory> <office_file>`
+
+The Document library provides both high-level methods for common operations and direct DOM access for complex scenarios.
+
+## Redlining workflow for document review
+
+This workflow allows you to plan comprehensive tracked changes using markdown before implementing them in OOXML. **CRITICAL**: For complete tracked changes, you must implement ALL changes systematically.
+
+**Batching Strategy**: Group related changes into batches of 3-10 changes. This makes debugging manageable while maintaining efficiency. Test each batch before moving to the next.
+
+**Principle: Minimal, Precise Edits**
+When implementing tracked changes, only mark text that actually changes. Repeating unchanged text makes edits harder to review and appears unprofessional. Break replacements into: [unchanged text] + [deletion] + [insertion] + [unchanged text]. Preserve the original run's RSID for unchanged text by extracting the `<w:r>` element from the original and reusing it.
+
+Example - Changing "30 days" to "60 days" in a sentence:
+```python
+# BAD - Replaces entire sentence
+'<w:del><w:r><w:delText>The term is 30 days.</w:delText></w:r></w:del><w:ins><w:r><w:t>The term is 60 days.</w:t></w:r></w:ins>'
+
+# GOOD - Only marks what changed, preserves original <w:r> for unchanged text
+'<w:r w:rsidR="00AB12CD"><w:t>The term is </w:t></w:r><w:del><w:r><w:delText>30</w:delText></w:r></w:del><w:ins><w:r><w:t>60</w:t></w:r></w:ins><w:r w:rsidR="00AB12CD"><w:t> days.</w:t></w:r>'
+```
+
+### Tracked changes workflow
+
+1. **Get markdown representation**: Convert document to markdown with tracked changes preserved:
+   ```bash
+   pandoc --track-changes=all path-to-file.docx -o current.md
+   ```
+
+2. **Identify and group changes**: Review the document and identify ALL changes needed, organizing them into logical batches:
+
+   **Location methods** (for finding changes in XML):
+   - Section/heading numbers (e.g., "Section 3.2", "Article IV")
+   - Paragraph identifiers if numbered
+   - Grep patterns with unique surrounding text
+   - Document structure (e.g., "first paragraph", "signature block")
+   - **DO NOT use markdown line numbers** - they don't map to XML structure
+
+   **Batch organization** (group 3-10 related changes per batch):
+   - By section: "Batch 1: Section 2 amendments", "Batch 2: Section 5 updates"
+   - By type: "Batch 1: Date corrections", "Batch 2: Party name changes"
+   - By complexity: Start with simple text replacements, then tackle complex structural changes
+   - Sequential: "Batch 1: Pages 1-3", "Batch 2: Pages 4-6"
+
+3. **Read documentation and unpack**:
+   - **MANDATORY - READ ENTIRE FILE**: Read [`ooxml.md`](ooxml.md) (~600 lines) completely from start to finish. **NEVER set any range limits when reading this file.** Pay special attention to the "Document Library" and "Tracked Change Patterns" sections.
+   - **Unpack the document**: `python ooxml/scripts/unpack.py <file.docx> <dir>`
+   - **Note the suggested RSID**: The unpack script will suggest an RSID to use for your tracked changes. Copy this RSID for use in step 4b.
+
+4. **Implement changes in batches**: Group changes logically (by section, by type, or by proximity) and implement them together in a single script. This approach:
+   - Makes debugging easier (smaller batch = easier to isolate errors)
+   - Allows incremental progress
+   - Maintains efficiency (batch size of 3-10 changes works well)
+
+   **Suggested batch groupings:**
+   - By document section (e.g., "Section 3 changes", "Definitions", "Termination clause")
+   - By change type (e.g., "Date changes", "Party name updates", "Legal term replacements")
+   - By proximity (e.g., "Changes on pages 1-3", "Changes in first half of document")
+
+   For each batch of related changes:
+
+   **a. Map text to XML**: Grep for text in `word/document.xml` to verify how text is split across `<w:r>` elements.
+
+   **b. Create and run script**: Use `get_node` to find nodes, implement changes, then `doc.save()`. See **"Document Library"** section in ooxml.md for patterns.
+
+   **Note**: Always grep `word/document.xml` immediately before writing a script to get current line numbers and verify text content. Line numbers change after each script run.
+
+5. **Pack the document**: After all batches are complete, convert the unpacked directory back to .docx:
+   ```bash
+   python ooxml/scripts/pack.py unpacked reviewed-document.docx
+   ```
+
+6. **Final verification**: Do a comprehensive check of the complete document:
+   - Convert final document to markdown:
+     ```bash
+     pandoc --track-changes=all reviewed-document.docx -o verification.md
+     ```
+   - Verify ALL changes were applied correctly:
+     ```bash
+     grep "original phrase" verification.md  # Should NOT find it
+     grep "replacement phrase" verification.md  # Should find it
+     ```
+   - Check that no unintended changes were introduced
+
+
+## Converting Documents to Images
+
+To visually analyze Word documents, convert them to images using a two-step process:
+
+1. **Convert DOCX to PDF**:
+   ```bash
+   soffice --headless --convert-to pdf document.docx
+   ```
+
+2. **Convert PDF pages to JPEG images**:
+   ```bash
+   pdftoppm -jpeg -r 150 document.pdf page
+   ```
+   This creates files like `page-1.jpg`, `page-2.jpg`, etc.
+
+Options:
+- `-r 150`: Sets resolution to 150 DPI (adjust for quality/size balance)
+- `-jpeg`: Output JPEG format (use `-png` for PNG if preferred)
+- `-f N`: First page to convert (e.g., `-f 2` starts from page 2)
+- `-l N`: Last page to convert (e.g., `-l 5` stops at page 5)
+- `page`: Prefix for output files
+
+Example for specific range:
+```bash
+pdftoppm -jpeg -r 150 -f 2 -l 5 document.pdf page  # Converts only pages 2-5
+```
+
+## Code Style Guidelines
+**IMPORTANT**: When generating code for DOCX operations:
+- Write concise code
+- Avoid verbose variable names and redundant operations
+- Avoid unnecessary print statements
+
+## Dependencies
+
+Required dependencies (install if not available):
+
+- **pandoc**: `sudo apt-get install pandoc` (for text extraction)
+- **docx**: `npm install -g docx` (for creating new documents)
+- **LibreOffice**: `sudo apt-get install libreoffice` (for PDF conversion)
+- **Poppler**: `sudo apt-get install poppler-utils` (for pdftoppm to convert PDF to images)
+- **defusedxml**: `pip install defusedxml` (for secure XML parsing)

package/data/skills/drug-discovery-search/SKILL.md

@@ -0,0 +1,214 @@
+---
+name: drug-discovery-search
+description: End-to-end drug discovery platform combining ChEMBL compounds, DrugBank, targets, and FDA labels. Natural language powered by Valyu.
+keywords:
+  - drug-discovery
+  - drug-development
+  - compound-screening
+  - target-validation
+  - comprehensive-search
+  - semantic-search
+license: MIT
+---
+
+
+# Drug Discovery Search
+
+Search across all major drug discovery databases (ChEMBL, DrugBank, FDA drug labels, Open Targets) simultaneously 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 compound, target, and drug information
+- **Image Links**: Includes molecular structures and data visualizations
+- **Comprehensive Coverage**: Search across ChEMBL, DrugBank, drug labels, and Open Targets simultaneously
+- **Unified Results**: Get results from all drug discovery sources in a single query
+
+## 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
+DRUG_DISCOVERY_SCRIPT=$(find ~/.claude/plugins/cache -name "search" -path "*/drug-discovery-search/*/scripts/*" -type f 2>/dev/null | head -1)
+```
+
+Then use the full path for all commands:
+```bash
+$DRUG_DISCOVERY_SCRIPT "JAK2 inhibitors" 20
+```
+
+## 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 drug discovery databases, 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
+
+- End-to-end drug discovery information
+- Target validation through compounds and trials
+- Complete drug development information
+- Compound optimization with target data
+- Safety and efficacy research
+## Output Format
+
+```json
+{
+  "success": true,
+  "type": "drug_discovery_search",
+  "query": "JAK2 inhibitors",
+  "result_count": 20,
+  "results": [
+    {
+      "title": "Compound/Drug/Target Title",
+      "url": "https://...",
+      "content": "Full data including compounds, targets, mechanisms...",
+      "source": "chembl|drugbank|drug-labels|open-targets",
+      "relevance_score": 0.95,
+      "images": ["https://example.com/structure.png"]
+    }
+  ],
+  "cost": 0.035
+}
+```
+
+## Processing Results
+
+### With jq
+
+```bash
+# Get titles
+scripts/search "query" 20 | jq -r '.results[].title'
+
+# Get URLs
+scripts/search "query" 20 | jq -r '.results[].url'
+
+# Extract full content
+scripts/search "query" 20 | jq -r '.results[].content'
+
+# Filter by source
+scripts/search "query" 20 | jq -r '.results[] | select(.source == "chembl") | .title'
+```
+
+## Common Use Cases
+
+### Target Identification
+
+```bash
+# Find validated targets and compounds
+scripts/search "BTK inhibitors for autoimmune diseases" 50
+```
+
+### Lead Optimization
+
+```bash
+# Search SAR and compound data
+scripts/search "EGFR inhibitors blood-brain barrier penetration" 40
+```
+
+### Drug Repurposing
+
+```bash
+# Find repurposing opportunities
+scripts/search "mTOR inhibitors cancer and aging" 30
+```
+
+### Safety Assessment
+
+```bash
+# Gather safety and interaction data
+scripts/search "tyrosine kinase inhibitors cardiac toxicity" 60
+```
+
+
+## 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 Drug Discovery 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-chembl", "valyu/valyu-drugbank", "valyu/valyu-drug-labels", "valyu/valyu-open-targets"],
+    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-chembl", "valyu/valyu-drugbank", "valyu/valyu-drug-labels", "valyu/valyu-open-targets"],
+  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/drug-interaction-checker/SKILL.md

@@ -0,0 +1,56 @@
+<!--
+# COPYRIGHT NOTICE
+# This file is part of the "Universal Biomedical Skills" project.
+# Copyright (c) 2026 MD BABU MIA, PhD <md.babu.mia@mssm.edu>
+# All Rights Reserved.
+#
+# This code is proprietary and confidential.
+# Unauthorized copying of this file, via any medium is strictly prohibited.
+#
+# Provenance: Authenticated by MD BABU MIA
+
+-->
+
+---
+name: 'drug-interaction-checker'
+description: 'Checks for potential drug-drug interactions (DDIs) between a list of medications.'
+measurable_outcome: Execute skill workflow successfully with valid output within 15 minutes.
+allowed-tools:
+  - read_file
+  - run_shell_command
+---
+
+
+# Drug-Drug Interaction (DDI) Checker
+
+This skill analyzes a list of medications to identify known interactions, focusing on safety and contraindications.
+
+## When to Use This Skill
+
+*   Reviewing patient medication lists.
+*   Prescribing new medications.
+*   Pharmacovigilance monitoring.
+
+## Core Capabilities
+
+1.  **Interaction Detection**: Identifies pairs of drugs with known interactions.
+2.  **Severity Grading**: Classifies interactions as Minor, Moderate, or Major.
+3.  **Clinical Recommendations**: Provides actionable advice (e.g., "Monitor K+ levels").
+
+## Workflow
+
+1.  **Input**: List of drug names (e.g., "Warfarin, Aspirin").
+2.  **Analysis**: Queries internal interaction database.
+3.  **Output**: Interaction report with severity and mechanisms.
+
+## Example Usage
+
+**User**: "Check interactions for Warfarin and Aspirin."
+
+**Agent Action**:
+```bash
+python3 Skills/Pharma/Drug_Interaction/impl.py --drugs "Warfarin, Aspirin"
+```
+
+
+<!-- AUTHOR_SIGNATURE: 9a7f3c2e-MD-BABU-MIA-2026-MSSM-SECURE -->

package/data/skills/drug-labels-search/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: drug-labels-search
+description: Search FDA drug labels with natural language queries. Official drug information, indications, and safety data via Valyu.
+keywords:
+  - fda-drug-labels
+  - drug-safety
+  - indications
+  - pharmacology
+  - drug-interactions
+  - semantic-search
+license: MIT
+---
+
+
+# Drug Labels Search
+
+Search the complete FDA drug labels database including prescribing information, warnings, and official labeling 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 drug label information including indications, dosing, warnings, and adverse reactions
+- **Image Links**: Includes label images when available
+- **Comprehensive Coverage**: Access to all FDA drug label data
+
+## 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
+DRUG_LABELS_SCRIPT=$(find ~/.claude/plugins/cache -name "search" -path "*/drug-labels-search/*/scripts/*" -type f 2>/dev/null | head -1)
+```
+
+Then use the full path for all commands:
+```bash
+$DRUG_LABELS_SCRIPT "ibuprofen warnings" 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 FDA drug labels, 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
+
+- Official FDA drug information and indications
+- Contraindications and warnings
+- Dosage and administration guidance
+- Clinical pharmacology data
+- Drug interaction information
+- Adverse reactions and safety monitoring
+## Output Format
+
+```json
+{
+  "success": true,
+  "type": "drug_labels_search",
+  "query": "ibuprofen warnings",
+  "result_count": 10,
+  "results": [
+    {
+      "title": "Drug Label Title",
+      "url": "https://fda.gov/...",
+      "content": "Label content, warnings, dosing...",
+      "source": "drug-labels",
+      "relevance_score": 0.95,
+      "images": ["https://example.com/label.jpg"]
+    }
+  ],
+  "cost": 0.025
+}
+```
+
+## Processing Results
+
+### With jq
+
+```bash
+# Get drug names
+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
+
+### Safety Information
+
+```bash
+# Find safety data
+scripts/search "anticoagulant bleeding risk warnings" 50
+```
+
+### Prescribing Guidance
+
+```bash
+# Search for dosing
+scripts/search "pediatric dosing guidelines for antibiotics" 20
+```
+
+### Drug Interactions
+
+```bash
+# Find interaction data
+scripts/search "CYP450 drug interaction warnings" 15
+```
+
+### Regulatory Information
+
+```bash
+# Search for approval data
+scripts/search "accelerated approval indications oncology" 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 Drug Labels 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-drug-labels"],
+    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-drug-labels"],
+  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.