@bgicli/bgicli 2.1.1 → 2.2.1

package/data/skills/kragen-knowledge-graph/SKILL.md

@@ -0,0 +1,68 @@
+<!--
+# 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: kragen-knowledge-graph
+description: Graph-RAG Solver
+keywords:
+  - knowledge-graph
+  - RAG
+  - reasoning
+  - graph-of-thoughts
+  - biomedical-qa
+measurable_outcome: Return a reasoning path and an answer supported by ≥3 knowledge graph nodes for complex biomedical questions with <5s latency.
+license: MIT
+metadata:
+  author: Bioinformatics Oxford
+  version: "1.0.0"
+compatibility:
+  - system: Python 3.9+
+allowed-tools:
+  - run_shell_command
+  - web_fetch
+---
+
+# KRAGEN (Knowledge Graph Enhanced RAG)
+
+A knowledge graph-enhanced Retrieval-Augmented Generation system for biomedical problem solving, using Graph-of-Thoughts (GoT) reasoning.
+
+## When to Use
+
+*   **Complex Reasoning**: Questions requiring multi-hop deduction (e.g., "How does gene A influence disease B via protein C?").
+*   **Hypothesis Verification**: Checking if a proposed mechanism is supported by existing knowledge graphs.
+*   **Literature Synthesis**: Combining facts from structured DBs and unstructured text.
+
+## Core Capabilities
+
+1.  **Graph Retrieval**: Query biomedical knowledge graphs (e.g., PrimeKG, SPOKE).
+2.  **Graph-of-Thoughts**: structured reasoning over retrieved nodes.
+3.  **Vector DB Integration**: Combines graph data with vector embeddings for hybrid search.
+
+## Workflow
+
+1.  **Input**: Natural language question.
+2.  **Retrieval**: Fetch relevant sub-graph and similar text chunks.
+3.  **Reasoning**: LLM traverses the graph to find connecting paths.
+4.  **Answer**: Generate response with citation of graph nodes.
+
+## Example Usage
+
+**User**: "Explain the mechanism connecting BRCA1 mutations to ovarian cancer."
+
+**Agent Action**:
+```bash
+python -m kragen.solve --question "BRCA1 mutations to ovarian cancer mechanism"
+```
+
+
+<!-- AUTHOR_SIGNATURE: 9a7f3c2e-MD-BABU-MIA-2026-MSSM-SECURE -->

package/data/skills/lab-results/SKILL.md

@@ -0,0 +1,35 @@
+<!--
+# 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: 'lab-results'
+description: 'Lab Results agent for healthcare workflows.'
+measurable_outcome: Execute skill workflow successfully with valid output within 15 minutes.
+allowed-tools:
+  - read_file
+  - run_shell_command
+---
+
+
+# Lab Results
+
+This skill implements the Lab Results workflow using Anthropic's Claude.
+
+## Usage
+
+```bash
+python3 Skills/Anthropic_Health_Stack/Lab_Results/coworker.py
+```
+
+
+<!-- AUTHOR_SIGNATURE: 9a7f3c2e-MD-BABU-MIA-2026-MSSM-SECURE -->

package/data/skills/labarchive-integration/SKILL.md

@@ -0,0 +1,262 @@
+---
+name: labarchive-integration
+description: "Electronic lab notebook API integration. Access notebooks, manage entries/attachments, backup notebooks, integrate with Protocols.io/Jupyter/REDCap, for programmatic ELN workflows."
+---
+
+# LabArchives Integration
+
+## Overview
+
+LabArchives is an electronic lab notebook platform for research documentation and data management. Access notebooks, manage entries and attachments, generate reports, and integrate with third-party tools programmatically via REST API.
+
+## When to Use This Skill
+
+This skill should be used when:
+- Working with LabArchives REST API for notebook automation
+- Backing up notebooks programmatically
+- Creating or managing notebook entries and attachments
+- Generating site reports and analytics
+- Integrating LabArchives with third-party tools (Protocols.io, Jupyter, REDCap)
+- Automating data upload to electronic lab notebooks
+- Managing user access and permissions programmatically
+
+## Core Capabilities
+
+### 1. Authentication and Configuration
+
+Set up API access credentials and regional endpoints for LabArchives API integration.
+
+**Prerequisites:**
+- Enterprise LabArchives license with API access enabled
+- API access key ID and password from LabArchives administrator
+- User authentication credentials (email and external applications password)
+
+**Configuration setup:**
+
+Use the `scripts/setup_config.py` script to create a configuration file:
+
+```bash
+python3 scripts/setup_config.py
+```
+
+This creates a `config.yaml` file with the following structure:
+
+```yaml
+api_url: https://api.labarchives.com/api  # or regional endpoint
+access_key_id: YOUR_ACCESS_KEY_ID
+access_password: YOUR_ACCESS_PASSWORD
+```
+
+**Regional API endpoints:**
+- US/International: `https://api.labarchives.com/api`
+- Australia: `https://auapi.labarchives.com/api`
+- UK: `https://ukapi.labarchives.com/api`
+
+For detailed authentication instructions and troubleshooting, refer to `references/authentication_guide.md`.
+
+### 2. User Information Retrieval
+
+Obtain user ID (UID) and access information required for subsequent API operations.
+
+**Workflow:**
+
+1. Call the `users/user_access_info` API method with login credentials
+2. Parse the XML/JSON response to extract the user ID (UID)
+3. Use the UID to retrieve detailed user information via `users/user_info_via_id`
+
+**Example using Python wrapper:**
+
+```python
+from labarchivespy.client import Client
+
+# Initialize client
+client = Client(api_url, access_key_id, access_password)
+
+# Get user access info
+login_params = {'login_or_email': user_email, 'password': auth_token}
+response = client.make_call('users', 'user_access_info', params=login_params)
+
+# Extract UID from response
+import xml.etree.ElementTree as ET
+uid = ET.fromstring(response.content)[0].text
+
+# Get detailed user info
+params = {'uid': uid}
+user_info = client.make_call('users', 'user_info_via_id', params=params)
+```
+
+### 3. Notebook Operations
+
+Manage notebook access, backup, and metadata retrieval.
+
+**Key operations:**
+
+- **List notebooks:** Retrieve all notebooks accessible to a user
+- **Backup notebooks:** Download complete notebook data with optional attachment inclusion
+- **Get notebook IDs:** Retrieve institution-defined notebook identifiers for integration with grants/project management systems
+- **Get notebook members:** List all users with access to a specific notebook
+- **Get notebook settings:** Retrieve configuration and permissions for notebooks
+
+**Notebook backup example:**
+
+Use the `scripts/notebook_operations.py` script:
+
+```bash
+# Backup with attachments (default, creates 7z archive)
+python3 scripts/notebook_operations.py backup --uid USER_ID --nbid NOTEBOOK_ID
+
+# Backup without attachments, JSON format
+python3 scripts/notebook_operations.py backup --uid USER_ID --nbid NOTEBOOK_ID --json --no-attachments
+```
+
+**API endpoint format:**
+```
+https://<api_url>/notebooks/notebook_backup?uid=<UID>&nbid=<NOTEBOOK_ID>&json=true&no_attachments=false
+```
+
+For comprehensive API method documentation, refer to `references/api_reference.md`.
+
+### 4. Entry and Attachment Management
+
+Create, modify, and manage notebook entries and file attachments.
+
+**Entry operations:**
+- Create new entries in notebooks
+- Add comments to existing entries
+- Create entry parts/components
+- Upload file attachments to entries
+
+**Attachment workflow:**
+
+Use the `scripts/entry_operations.py` script:
+
+```bash
+# Upload attachment to an entry
+python3 scripts/entry_operations.py upload --uid USER_ID --nbid NOTEBOOK_ID --entry-id ENTRY_ID --file /path/to/file.pdf
+
+# Create a new entry with text content
+python3 scripts/entry_operations.py create --uid USER_ID --nbid NOTEBOOK_ID --title "Experiment Results" --content "Results from today's experiment..."
+```
+
+**Supported file types:**
+- Documents (PDF, DOCX, TXT)
+- Images (PNG, JPG, TIFF)
+- Data files (CSV, XLSX, HDF5)
+- Scientific formats (CIF, MOL, PDB)
+- Archives (ZIP, 7Z)
+
+### 5. Site Reports and Analytics
+
+Generate institutional reports on notebook usage, activity, and compliance (Enterprise feature).
+
+**Available reports:**
+- Detailed Usage Report: User activity metrics and engagement statistics
+- Detailed Notebook Report: Notebook metadata, member lists, and settings
+- PDF/Offline Notebook Generation Report: Export tracking for compliance
+- Notebook Members Report: Access control and collaboration analytics
+- Notebook Settings Report: Configuration and permission auditing
+
+**Report generation:**
+
+```python
+# Generate detailed usage report
+response = client.make_call('site_reports', 'detailed_usage_report',
+                           params={'start_date': '2025-01-01', 'end_date': '2025-10-20'})
+```
+
+### 6. Third-Party Integrations
+
+LabArchives integrates with numerous scientific software platforms. This skill provides guidance on leveraging these integrations programmatically.
+
+**Supported integrations:**
+- **Protocols.io:** Export protocols directly to LabArchives notebooks
+- **GraphPad Prism:** Export analyses and figures (Version 8+)
+- **SnapGene:** Direct molecular biology workflow integration
+- **Geneious:** Bioinformatics analysis export
+- **Jupyter:** Embed Jupyter notebooks as entries
+- **REDCap:** Clinical data capture integration
+- **Qeios:** Research publishing platform
+- **SciSpace:** Literature management
+
+**OAuth authentication:**
+LabArchives now uses OAuth for all new integrations. Legacy integrations may use API key authentication.
+
+For detailed integration setup instructions and use cases, refer to `references/integrations.md`.
+
+## Common Workflows
+
+### Complete notebook backup workflow
+
+1. Authenticate and obtain user ID
+2. List all accessible notebooks
+3. Iterate through notebooks and backup each one
+4. Store backups with timestamp metadata
+
+```bash
+# Complete backup script
+python3 scripts/notebook_operations.py backup-all --email user@example.edu --password AUTH_TOKEN
+```
+
+### Automated data upload workflow
+
+1. Authenticate with LabArchives API
+2. Identify target notebook and entry
+3. Upload experimental data files
+4. Add metadata comments to entries
+5. Generate activity report
+
+### Integration workflow example (Jupyter → LabArchives)
+
+1. Export Jupyter notebook to HTML or PDF
+2. Use entry_operations.py to upload to LabArchives
+3. Add comment with execution timestamp and environment info
+4. Tag entry for easy retrieval
+
+## Python Package Installation
+
+Install the `labarchives-py` wrapper for simplified API access:
+
+```bash
+git clone https://github.com/mcmero/labarchives-py
+cd labarchives-py
+uv pip install .
+```
+
+Alternatively, use direct HTTP requests via Python's `requests` library for custom implementations.
+
+## Best Practices
+
+1. **Rate limiting:** Implement appropriate delays between API calls to avoid throttling
+2. **Error handling:** Always wrap API calls in try-except blocks with appropriate logging
+3. **Authentication security:** Store credentials in environment variables or secure config files (never in code)
+4. **Backup verification:** After notebook backup, verify file integrity and completeness
+5. **Incremental operations:** For large notebooks, use pagination and batch processing
+6. **Regional endpoints:** Use the correct regional API endpoint for optimal performance
+
+## Troubleshooting
+
+**Common issues:**
+
+- **401 Unauthorized:** Verify access key ID and password are correct; check API access is enabled for your account
+- **404 Not Found:** Confirm notebook ID (nbid) exists and user has access permissions
+- **403 Forbidden:** Check user permissions for the requested operation
+- **Empty response:** Ensure required parameters (uid, nbid) are provided correctly
+- **Attachment upload failures:** Verify file size limits and format compatibility
+
+For additional support, contact LabArchives at support@labarchives.com.
+
+## Resources
+
+This skill includes bundled resources to support LabArchives API integration:
+
+### scripts/
+
+- `setup_config.py`: Interactive configuration file generator for API credentials
+- `notebook_operations.py`: Utilities for listing, backing up, and managing notebooks
+- `entry_operations.py`: Tools for creating entries and uploading attachments
+
+### references/
+
+- `api_reference.md`: Comprehensive API endpoint documentation with parameters and examples
+- `authentication_guide.md`: Detailed authentication setup and configuration instructions
+- `integrations.md`: Third-party integration setup guides and use cases

package/data/skills/labstep/SKILL.md

@@ -0,0 +1,208 @@
+---
+name: labstep
+description: Interact with the Labstep electronic lab notebook API using labstepPy. Query experiments, protocols, resources, inventory, and other lab entities.
+version: 0.1.0
+metadata:
+  openclaw:
+    requires:
+      bins:
+        - python3
+      env:
+        - LABSTEP_API_KEY
+      config: []
+    always: false
+    emoji: "🔬"
+    homepage: https://www.labstep.com
+    os: [macos, linux]
+    install:
+      - kind: uv
+        package: labstep
+        bins: []
+---
+
+# 🔬 Labstep
+
+You are **Labstep**, a specialised ClawBio agent for interacting with the Labstep electronic lab notebook API. Your role is to query experiments, protocols, resources, and inventory using the `labstep` Python package (labstepPy).
+
+## Core Capabilities
+
+1. **Query experiments**: Search, list, and retrieve experiment details, data fields, tables, files, and comments
+2. **Query protocols**: Fetch protocols, steps, inventory fields, and versioning history
+3. **Query resources & inventory**: Look up reagents, resource items, locations, and metadata
+
+## Authentication
+
+Authenticate using the `LABSTEP_API_KEY` env var, or fall back to `.claude/settings.json`:
+
+```python
+import os, json, labstep
+from pathlib import Path
+
+def get_labstep_apikey() -> str:
+    """Get Labstep API key from env var or .claude/settings.json."""
+    key = os.environ.get("LABSTEP_API_KEY")
+    if key:
+        return key
+    settings = Path(".claude/settings.json")
+    if settings.exists():
+        cfg = json.loads(settings.read_text())
+        key = cfg.get("skillsConfig", {}).get("labstep", {}).get("apiKey")
+        if key:
+            return key
+    raise RuntimeError("No Labstep API key found. Set LABSTEP_API_KEY or configure .claude/settings.json")
+
+user = labstep.authenticate(apikey=get_labstep_apikey())
+```
+
+## Read-Only Policy
+
+This skill uses a read-only service account. **Do not call any write methods**
+(`newExperiment`, `edit`, `delete`, `addDataField`, etc.) unless the user
+explicitly confirms with the phrase **"confirm write"**. If the user asks you
+to modify a Labstep entry, reply:
+
+> I can [describe the change]. To proceed, please confirm write: `confirm write`
+
+## Workflow
+
+When the user asks about lab experiments, protocols, or inventory:
+
+1. **Authenticate**: Use `get_labstep_apikey()` to connect to Labstep
+2. **Query**: Use the appropriate API methods to fetch the requested data
+3. **Present**: Display results in a clear, structured format
+4. **Chain**: Pass data to other ClawBio skills if needed (e.g., lit-synthesizer for related papers)
+
+## Key Entity Methods
+
+### User (`user`)
+All operations start from the authenticated `user` object.
+
+**Get single entities:**
+- `user.getExperiment(id)`, `user.getProtocol(id)`, `user.getResource(id)`
+- `user.getResourceItem(id)`, `user.getResourceCategory(id)`, `user.getResourceLocation(guid)`
+- `user.getWorkspace(id)`, `user.getDevice(id)`, `user.getFile(id)`
+- `user.getOrganization()`, `user.getAPIKey(id)`
+
+**List entities (all support `count`, `search_query`):**
+- `user.getExperiments()`, `user.getProtocols()`, `user.getResources()`
+- `user.getResourceItems()`, `user.getResourceCategorys()`, `user.getResourceLocations()`
+- `user.getWorkspaces()`, `user.getDevices()`, `user.getTags()`
+- `user.getOrderRequests()`, `user.getPurchaseOrders()`
+
+**Create entities (requires "confirm write"):**
+- `user.newExperiment(name, entry=None, template_id=None)`
+- `user.newProtocol(name)`
+- `user.newResource(name, resource_category_id=None)`
+- `user.newResourceCategory(name)`
+- `user.newResourceLocation(name, outer_location_guid=None)`
+- `user.newWorkspace(name)`
+- `user.newTag(name, type)` — type is `'experiment'` or `'protocol'` or `'resource'`
+- `user.newCollection(name, type='experiment')`
+- `user.newDevice(name, device_category_id=None)`
+- `user.newOrderRequest(resource_id, purchase_order_id=None, quantity=1)`
+- `user.newFile(filepath=None, rawData=None)`
+- `user.setWorkspace(workspace_id)` — switch active workspace
+
+### Experiments
+```python
+exp = user.getExperiment(id)
+exp.getProtocols()
+exp.getDataFields()
+exp.getTables()
+exp.getFiles()
+exp.getTags()
+exp.getComments()
+exp.getCollections()
+exp.getCollaborators()
+exp.getSharelink()
+exp.export(path)
+```
+
+### Protocols
+```python
+protocol = user.getProtocol(id)
+protocol.getVersions()
+protocol.getSteps()
+protocol.getDataFields()
+protocol.getInventoryFields()
+protocol.getTimers()
+protocol.getTables()
+protocol.getFiles()
+```
+
+### Resources / Inventory
+```python
+resource = user.getResource(id)
+resource.getResourceCategory()
+resource.getItems()
+resource.getChemicalMetadata()
+resource.getMetadata()
+
+item = user.getResourceItem(id)
+item.getLocation()
+item.getLineageParents()
+item.getLineageChildren()
+
+loc = user.getResourceLocation(guid)
+loc.getItems()
+loc.getInnerLocations()
+```
+
+## Example Queries
+
+- "Show me my recent experiments"
+- "What protocols are in the workspace?"
+- "Find experiments about scTIP-seq"
+- "List all reagents in the inventory"
+- "What are the data fields for experiment 12345?"
+- "Show me the protocol steps for my latest experiment"
+
+## Common Patterns
+
+**Search experiments:**
+```python
+exps = user.getExperiments(search_query='PCR', count=20)
+for e in exps:
+    print(e.id, e.name)
+```
+
+**Switch workspace then query:**
+```python
+workspaces = user.getWorkspaces()
+user.setWorkspace(workspaces[0].id)
+exps = user.getExperiments(count=10)
+```
+
+## Dependencies
+
+**Required**:
+- `labstep` (labstepPy — Labstep API client)
+
+**Environment**:
+- `LABSTEP_API_KEY` — API key for authentication (or configure in `.claude/settings.json`)
+
+## Safety
+
+- Read-only by default; write operations require explicit user confirmation ("confirm write")
+- Genetic and experimental data stays local — no external uploads
+- API key is scoped to a read-only service account
+
+## Integration with Bio Orchestrator
+
+This skill is invoked by the Bio Orchestrator when:
+- The user asks about lab experiments, protocols, or inventory
+- The user wants to cross-reference Labstep metadata with genomic analysis results
+
+It can be chained with:
+- **lit-synthesizer**: Find papers related to experiment protocols or results
+- **scrna-orchestrator**: Link single-cell experiments in Labstep to h5ad analysis
+- **seq-wrangler**: Connect sequencing QC data to Labstep experiment records
+
+## Notes
+
+- Most list methods accept `count` (int) and `search_query` (str) parameters
+- `fieldType` for data fields: `'default'` (text), `'numeric'`, `'date'`, `'file'`
+- Dates are strings in ISO format: `'YYYY-MM-DD'`
+- After login, workspace defaults to the user's personal workspace; use `setWorkspace()` to switch
+- Entity IDs are integers; resource location GUIDs are strings
+- Protocol body text lives on `protocol-collection.last_version.state` (ProseMirror JSON), not on experiment-linked copies