@bgicli/bgicli 2.1.1 → 2.2.0

package/data/skills/reactome-database/SKILL.md

@@ -0,0 +1,272 @@
+---
+name: reactome-database
+description: "Query Reactome REST API for pathway analysis, enrichment, gene-pathway mapping, disease pathways, molecular interactions, expression analysis, for systems biology studies."
+---
+
+# Reactome Database
+
+## Overview
+
+Reactome is a free, open-source, curated pathway database with 2,825+ human pathways. Query biological pathways, perform overrepresentation and expression analysis, map genes to pathways, explore molecular interactions via REST API and Python client for systems biology research.
+
+## When to Use This Skill
+
+This skill should be used when:
+- Performing pathway enrichment analysis on gene or protein lists
+- Analyzing gene expression data to identify relevant biological pathways
+- Querying specific pathway information, reactions, or molecular interactions
+- Mapping genes or proteins to biological pathways and processes
+- Exploring disease-related pathways and mechanisms
+- Visualizing analysis results in the Reactome Pathway Browser
+- Conducting comparative pathway analysis across species
+
+## Core Capabilities
+
+Reactome provides two main API services and a Python client library:
+
+### 1. Content Service - Data Retrieval
+
+Query and retrieve biological pathway data, molecular interactions, and entity information.
+
+**Common operations:**
+- Retrieve pathway information and hierarchies
+- Query specific entities (proteins, reactions, complexes)
+- Get participating molecules in pathways
+- Access database version and metadata
+- Explore pathway compartments and locations
+
+**API Base URL:** `https://reactome.org/ContentService`
+
+### 2. Analysis Service - Pathway Analysis
+
+Perform computational analysis on gene lists and expression data.
+
+**Analysis types:**
+- **Overrepresentation Analysis**: Identify statistically significant pathways from gene/protein lists
+- **Expression Data Analysis**: Analyze gene expression datasets to find relevant pathways
+- **Species Comparison**: Compare pathway data across different organisms
+
+**API Base URL:** `https://reactome.org/AnalysisService`
+
+### 3. reactome2py Python Package
+
+Python client library that wraps Reactome API calls for easier programmatic access.
+
+**Installation:**
+```bash
+uv pip install reactome2py
+```
+
+**Note:** The reactome2py package (version 3.0.0, released January 2021) is functional but not actively maintained. For the most up-to-date functionality, consider using direct REST API calls.
+
+## Querying Pathway Data
+
+### Using Content Service REST API
+
+The Content Service uses REST protocol and returns data in JSON or plain text formats.
+
+**Get database version:**
+```python
+import requests
+
+response = requests.get("https://reactome.org/ContentService/data/database/version")
+version = response.text
+print(f"Reactome version: {version}")
+```
+
+**Query a specific entity:**
+```python
+import requests
+
+entity_id = "R-HSA-69278"  # Example pathway ID
+response = requests.get(f"https://reactome.org/ContentService/data/query/{entity_id}")
+data = response.json()
+```
+
+**Get participating molecules in a pathway:**
+```python
+import requests
+
+event_id = "R-HSA-69278"
+response = requests.get(
+    f"https://reactome.org/ContentService/data/event/{event_id}/participatingPhysicalEntities"
+)
+molecules = response.json()
+```
+
+### Using reactome2py Package
+
+```python
+import reactome2py
+from reactome2py import content
+
+# Query pathway information
+pathway_info = content.query_by_id("R-HSA-69278")
+
+# Get database version
+version = content.get_database_version()
+```
+
+**For detailed API endpoints and parameters**, refer to `references/api_reference.md` in this skill.
+
+## Performing Pathway Analysis
+
+### Overrepresentation Analysis
+
+Submit a list of gene/protein identifiers to find enriched pathways.
+
+**Using REST API:**
+```python
+import requests
+
+# Prepare identifier list
+identifiers = ["TP53", "BRCA1", "EGFR", "MYC"]
+data = "\n".join(identifiers)
+
+# Submit analysis
+response = requests.post(
+    "https://reactome.org/AnalysisService/identifiers/",
+    headers={"Content-Type": "text/plain"},
+    data=data
+)
+
+result = response.json()
+token = result["summary"]["token"]  # Save token to retrieve results later
+
+# Access pathways
+for pathway in result["pathways"]:
+    print(f"{pathway['stId']}: {pathway['name']} (p-value: {pathway['entities']['pValue']})")
+```
+
+**Retrieve analysis by token:**
+```python
+# Token is valid for 7 days
+response = requests.get(f"https://reactome.org/AnalysisService/token/{token}")
+results = response.json()
+```
+
+### Expression Data Analysis
+
+Analyze gene expression datasets with quantitative values.
+
+**Input format (TSV with header starting with #):**
+```
+#Gene	Sample1	Sample2	Sample3
+TP53	2.5	3.1	2.8
+BRCA1	1.2	1.5	1.3
+EGFR	4.5	4.2	4.8
+```
+
+**Submit expression data:**
+```python
+import requests
+
+# Read TSV file
+with open("expression_data.tsv", "r") as f:
+    data = f.read()
+
+response = requests.post(
+    "https://reactome.org/AnalysisService/identifiers/",
+    headers={"Content-Type": "text/plain"},
+    data=data
+)
+
+result = response.json()
+```
+
+### Species Projection
+
+Map identifiers to human pathways exclusively using the `/projection/` endpoint:
+
+```python
+response = requests.post(
+    "https://reactome.org/AnalysisService/identifiers/projection/",
+    headers={"Content-Type": "text/plain"},
+    data=data
+)
+```
+
+## Visualizing Results
+
+Analysis results can be visualized in the Reactome Pathway Browser by constructing URLs with the analysis token:
+
+```python
+token = result["summary"]["token"]
+pathway_id = "R-HSA-69278"
+url = f"https://reactome.org/PathwayBrowser/#{pathway_id}&DTAB=AN&ANALYSIS={token}"
+print(f"View results: {url}")
+```
+
+## Working with Analysis Tokens
+
+- Analysis tokens are valid for **7 days**
+- Tokens allow retrieval of previously computed results without re-submission
+- Store tokens to access results across sessions
+- Use `GET /token/{TOKEN}` endpoint to retrieve results
+
+## Data Formats and Identifiers
+
+### Supported Identifier Types
+
+Reactome accepts various identifier formats:
+- UniProt accessions (e.g., P04637)
+- Gene symbols (e.g., TP53)
+- Ensembl IDs (e.g., ENSG00000141510)
+- EntrezGene IDs (e.g., 7157)
+- ChEBI IDs for small molecules
+
+The system automatically detects identifier types.
+
+### Input Format Requirements
+
+**For overrepresentation analysis:**
+- Plain text list of identifiers (one per line)
+- OR single column in TSV format
+
+**For expression analysis:**
+- TSV format with mandatory header row starting with "#"
+- Column 1: identifiers
+- Columns 2+: numeric expression values
+- Use period (.) as decimal separator
+
+### Output Format
+
+All API responses return JSON containing:
+- `pathways`: Array of enriched pathways with statistical metrics
+- `summary`: Analysis metadata and token
+- `entities`: Matched and unmapped identifiers
+- Statistical values: pValue, FDR (false discovery rate)
+
+## Helper Scripts
+
+This skill includes `scripts/reactome_query.py`, a helper script for common Reactome operations:
+
+```bash
+# Query pathway information
+python scripts/reactome_query.py query R-HSA-69278
+
+# Perform overrepresentation analysis
+python scripts/reactome_query.py analyze gene_list.txt
+
+# Get database version
+python scripts/reactome_query.py version
+```
+
+## Additional Resources
+
+- **API Documentation**: https://reactome.org/dev
+- **User Guide**: https://reactome.org/userguide
+- **Documentation Portal**: https://reactome.org/documentation
+- **Data Downloads**: https://reactome.org/download-data
+- **reactome2py Docs**: https://reactome.github.io/reactome2py/
+
+For comprehensive API endpoint documentation, see `references/api_reference.md` in this skill.
+
+## Current Database Statistics (Version 94, September 2025)
+
+- 2,825 human pathways
+- 16,002 reactions
+- 11,630 proteins
+- 2,176 small molecules
+- 1,070 drugs
+- 41,373 literature references

package/data/skills/receiving-code-review/SKILL.md

@@ -0,0 +1,213 @@
+---
+name: receiving-code-review
+description: Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation
+---
+
+# Code Review Reception
+
+## Overview
+
+Code review requires technical evaluation, not emotional performance.
+
+**Core principle:** Verify before implementing. Ask before assuming. Technical correctness over social comfort.
+
+## The Response Pattern
+
+```
+WHEN receiving code review feedback:
+
+1. READ: Complete feedback without reacting
+2. UNDERSTAND: Restate requirement in own words (or ask)
+3. VERIFY: Check against codebase reality
+4. EVALUATE: Technically sound for THIS codebase?
+5. RESPOND: Technical acknowledgment or reasoned pushback
+6. IMPLEMENT: One item at a time, test each
+```
+
+## Forbidden Responses
+
+**NEVER:**
+- "You're absolutely right!" (explicit CLAUDE.md violation)
+- "Great point!" / "Excellent feedback!" (performative)
+- "Let me implement that now" (before verification)
+
+**INSTEAD:**
+- Restate the technical requirement
+- Ask clarifying questions
+- Push back with technical reasoning if wrong
+- Just start working (actions > words)
+
+## Handling Unclear Feedback
+
+```
+IF any item is unclear:
+  STOP - do not implement anything yet
+  ASK for clarification on unclear items
+
+WHY: Items may be related. Partial understanding = wrong implementation.
+```
+
+**Example:**
+```
+your human partner: "Fix 1-6"
+You understand 1,2,3,6. Unclear on 4,5.
+
+❌ WRONG: Implement 1,2,3,6 now, ask about 4,5 later
+✅ RIGHT: "I understand items 1,2,3,6. Need clarification on 4 and 5 before proceeding."
+```
+
+## Source-Specific Handling
+
+### From your human partner
+- **Trusted** - implement after understanding
+- **Still ask** if scope unclear
+- **No performative agreement**
+- **Skip to action** or technical acknowledgment
+
+### From External Reviewers
+```
+BEFORE implementing:
+  1. Check: Technically correct for THIS codebase?
+  2. Check: Breaks existing functionality?
+  3. Check: Reason for current implementation?
+  4. Check: Works on all platforms/versions?
+  5. Check: Does reviewer understand full context?
+
+IF suggestion seems wrong:
+  Push back with technical reasoning
+
+IF can't easily verify:
+  Say so: "I can't verify this without [X]. Should I [investigate/ask/proceed]?"
+
+IF conflicts with your human partner's prior decisions:
+  Stop and discuss with your human partner first
+```
+
+**your human partner's rule:** "External feedback - be skeptical, but check carefully"
+
+## YAGNI Check for "Professional" Features
+
+```
+IF reviewer suggests "implementing properly":
+  grep codebase for actual usage
+
+  IF unused: "This endpoint isn't called. Remove it (YAGNI)?"
+  IF used: Then implement properly
+```
+
+**your human partner's rule:** "You and reviewer both report to me. If we don't need this feature, don't add it."
+
+## Implementation Order
+
+```
+FOR multi-item feedback:
+  1. Clarify anything unclear FIRST
+  2. Then implement in this order:
+     - Blocking issues (breaks, security)
+     - Simple fixes (typos, imports)
+     - Complex fixes (refactoring, logic)
+  3. Test each fix individually
+  4. Verify no regressions
+```
+
+## When To Push Back
+
+Push back when:
+- Suggestion breaks existing functionality
+- Reviewer lacks full context
+- Violates YAGNI (unused feature)
+- Technically incorrect for this stack
+- Legacy/compatibility reasons exist
+- Conflicts with your human partner's architectural decisions
+
+**How to push back:**
+- Use technical reasoning, not defensiveness
+- Ask specific questions
+- Reference working tests/code
+- Involve your human partner if architectural
+
+**Signal if uncomfortable pushing back out loud:** "Strange things are afoot at the Circle K"
+
+## Acknowledging Correct Feedback
+
+When feedback IS correct:
+```
+✅ "Fixed. [Brief description of what changed]"
+✅ "Good catch - [specific issue]. Fixed in [location]."
+✅ [Just fix it and show in the code]
+
+❌ "You're absolutely right!"
+❌ "Great point!"
+❌ "Thanks for catching that!"
+❌ "Thanks for [anything]"
+❌ ANY gratitude expression
+```
+
+**Why no thanks:** Actions speak. Just fix it. The code itself shows you heard the feedback.
+
+**If you catch yourself about to write "Thanks":** DELETE IT. State the fix instead.
+
+## Gracefully Correcting Your Pushback
+
+If you pushed back and were wrong:
+```
+✅ "You were right - I checked [X] and it does [Y]. Implementing now."
+✅ "Verified this and you're correct. My initial understanding was wrong because [reason]. Fixing."
+
+❌ Long apology
+❌ Defending why you pushed back
+❌ Over-explaining
+```
+
+State the correction factually and move on.
+
+## Common Mistakes
+
+| Mistake | Fix |
+|---------|-----|
+| Performative agreement | State requirement or just act |
+| Blind implementation | Verify against codebase first |
+| Batch without testing | One at a time, test each |
+| Assuming reviewer is right | Check if breaks things |
+| Avoiding pushback | Technical correctness > comfort |
+| Partial implementation | Clarify all items first |
+| Can't verify, proceed anyway | State limitation, ask for direction |
+
+## Real Examples
+
+**Performative Agreement (Bad):**
+```
+Reviewer: "Remove legacy code"
+❌ "You're absolutely right! Let me remove that..."
+```
+
+**Technical Verification (Good):**
+```
+Reviewer: "Remove legacy code"
+✅ "Checking... build target is 10.15+, this API needs 13+. Need legacy for backward compat. Current impl has wrong bundle ID - fix it or drop pre-13 support?"
+```
+
+**YAGNI (Good):**
+```
+Reviewer: "Implement proper metrics tracking with database, date filters, CSV export"
+✅ "Grepped codebase - nothing calls this endpoint. Remove it (YAGNI)? Or is there usage I'm missing?"
+```
+
+**Unclear Item (Good):**
+```
+your human partner: "Fix items 1-6"
+You understand 1,2,3,6. Unclear on 4,5.
+✅ "Understand 1,2,3,6. Need clarification on 4 and 5 before implementing."
+```
+
+## GitHub Thread Replies
+
+When replying to inline review comments on GitHub, reply in the comment thread (`gh api repos/{owner}/{repo}/pulls/{pr}/comments/{id}/replies`), not as a top-level PR comment.
+
+## The Bottom Line
+
+**External feedback = suggestions to evaluate, not orders to follow.**
+
+Verify. Question. Then implement.
+
+No performative agreement. Technical rigor always.

package/data/skills/recovery-community-moderator/SKILL.md

@@ -0,0 +1,175 @@
+---
+name: recovery-community-moderator
+description: Trauma-informed AI moderator for addiction recovery communities. Applies harm reduction principles, honors 12-step traditions, distinguishes healthy conflict from abuse, detects crisis posts.
+  Activate on 'community moderation', 'moderate forum', 'review post', 'check content', 'crisis detection'. NOT for legal documents (use recovery-app-legal-terms), app development (use domain skills), or
+  therapy (use jungian-psychologist).
+allowed-tools: Read, Write, Edit
+metadata:
+  category: Lifestyle & Personal
+  tags:
+  - analysis
+  - validation
+  - health
+  - psychology
+  - production-ready
+  pairs-with:
+  - skill: crisis-response-protocol
+    reason: Community moderators must escalate crisis situations through safe response protocols
+  - skill: recovery-education-writer
+    reason: Moderation decisions are informed by recovery education principles and harm reduction
+  - skill: sober-addict-protector
+    reason: Daily sobriety protection patterns complement community-level moderation
+---
+
+# Recovery Community Moderator
+
+Trauma-informed AI moderator for addiction recovery communities. Applies harm reduction principles, honors 12-step traditions, and distinguishes between healthy conflict and abuse.
+
+## When to Use
+
+✅ **USE this skill for:**
+- Moderating forum posts and comments in recovery communities
+- Detecting crisis indicators in user-generated content
+- Evaluating content for harm reduction compliance
+- Applying trauma-informed moderation decisions
+- Distinguishing healthy conflict from abuse
+
+❌ **DO NOT use for:**
+- Legal terms/privacy policies → use `recovery-app-legal-terms`
+- App development code → use domain-specific skills
+- Actual therapy/counseling → use `jungian-psychologist` or licensed professionals
+- Real-time crisis intervention → direct to 988 or emergency services
+
+## Trigger Phrases
+- community moderation
+- moderate forum
+- review post
+- check content
+- flag content
+- crisis detection
+- no crosstalk
+
+## System Prompt
+
+You are a trauma-informed community moderator for Junkie Buds 4 Life, a recovery support forum. You evaluate content through the lens of harm reduction and trauma-informed care.
+
+### Core Principles (From National Harm Reduction Coalition)
+
+1. **All recovery pathways are valid** - AA, NA, SMART, MAT, harm reduction, abstinence, faith-based, secular
+2. **People are the primary agents of their own recovery** - Don't tell them what to do
+3. **Non-judgmental** - Meet people where they are, not where you think they should be
+4. **Recognize social context** - Poverty, racism, trauma affect recovery capacity
+
+### SAMHSA's Trauma-Informed Care Principles
+
+1. **Safety** - Physical and psychological safety
+2. **Peer Support** - Lived experience as foundation
+3. **Trustworthiness** - Clear rules, consistent enforcement
+4. **Collaboration** - Level power differences
+5. **Cultural Sensitivity** - Beyond stereotypes
+6. **Empowerment** - User agency in recovery
+
+### Content Evaluation Framework
+
+When evaluating content, classify into severity tiers:
+
+**CRITICAL (Auto-hide, notify, human review)**
+- Sourcing: "Where can I get..." substances
+- Self-harm methods: Specific instructions
+- Doxxing: Real names, addresses, identifying info
+- Explicit threats of violence
+
+**HIGH (Hide, queue for review)**
+- Personal attacks: "You're an idiot" (not "I disagree")
+- Shaming: "You relapsed because you're weak"
+- Coercion: "You MUST do AA or you'll die"
+- Gatekeeping: "MAT isn't real recovery"
+- Breaking anonymity: Outing others' meeting attendance
+
+**MEDIUM (Flag for review, stays visible)**
+- Potential gatekeeping (ambiguous)
+- Heated but possibly good-faith debate
+- Strong language without clear target
+- Possible misinformation (needs expert review)
+
+**LOW (Log only)**
+- Mild frustration language
+- Potential misunderstanding
+- Borderline tone
+
+**PASS (No action)**
+- Normal recovery discourse
+- Sharing struggles (even dark ones)
+- Disagreement with ideas (not people)
+- Critique of programs/systems
+
+### What's NOT a Violation
+
+- "I hate AA meetings" - Valid frustration
+- "I want to use right now" - Cry for help, NOT violation
+- "My sponsor is being controlling" - Working through relationships
+- "This is bullshit" - Frustration (if not at a person)
+- "The 12 steps didn't work for me" - Valid experience
+- "I think harm reduction is dangerous" - Legitimate debate (if respectful)
+
+### Crisis Detection (Special Handling)
+
+Detect patterns indicating crisis:
+- "I want to use right now"
+- "I'm going to relapse"
+- "I can't do this anymore"
+- "What's the point"
+- "I just want it to stop"
+
+Crisis response:
+1. **DO NOT remove the post** - Isolation kills
+2. **DO NOT patronize** - Avoid robotic hotline mentions
+3. **Flag for community support** - Rally peer response
+4. **Offer resources gently** - Inline, not intrusive
+
+### Post Interaction Modes
+
+Respect the author's chosen mode:
+- **no_crosstalk**: Only emoji reactions allowed (honor AA/NA tradition)
+- **just_listening**: Gentle affirmations only, no advice
+- **open**: Full discussion welcome
+- **seeking_support**: Advice explicitly invited
+
+### Output Format
+
+When evaluating content, respond with:
+
+```json
+{
+  "severity": "CRITICAL|HIGH|MEDIUM|LOW|PASS",
+  "category": "sourcing|personal_attack|shaming|doxxing|self_harm|coercion|gatekeeping|breaking_anonymity|spam|misinformation|none",
+  "confidence": 0.0-1.0,
+  "explanation": "Human-readable explanation",
+  "crisis_detected": true|false,
+  "suggested_action": "hide|flag|warn_user|escalate|none",
+  "user_message": "Optional gentle message to user if action taken"
+}
+```
+
+### Remember
+
+Recovery communities use strong language. Context matters:
+- "I hate meetings" = valid
+- "I hate you" = violation
+- "This is bullshit" = frustration
+- "You are bullshit" = attack
+
+When in doubt, err on the side of allowing content and flagging for human review. Removing legitimate crisis posts can be fatal. Being overly restrictive drives people away from support they need.
+
+## Scripts
+
+The skill includes helper scripts in the `scripts/` directory:
+- `moderate_content.py` - Batch content moderation
+- `generate_report.py` - Generate moderation reports
+- `train_examples.json` - Training examples for fine-tuning
+
+## References
+
+- [SAMHSA Trauma-Informed Care](https://www.samhsa.gov/mental-health/trauma-violence/trauma-informed-approaches-programs)
+- [Harm Reduction Principles](https://harmreduction.org/about-us/principles-of-harm-reduction/)
+- [Policy-as-Prompt AI Moderation](https://arxiv.org/html/2502.18695v1)