@wentorai/research-plugins 1.0.0

package/skills/literature/discovery/paper-tracking-guide/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: paper-tracking-guide
+description: "Track new publications via RSS, alerts, and citation notifications"
+metadata:
+  openclaw:
+    emoji: "🔔"
+    category: "literature"
+    subcategory: "discovery"
+    keywords: ["literature alert", "citation notification", "RSS feed", "new publication tracking", "related papers"]
+    source: "N/A"
+---
+
+# Paper Tracking Guide
+
+## Overview
+
+Staying current with the literature is one of the most persistent challenges in academic research. With over 5 million new papers published annually across all disciplines, manual browsing of journals and preprint servers is neither scalable nor reliable. Researchers who set up automated tracking systems gain a significant advantage: they discover relevant work earlier, avoid duplicating existing results, and identify collaboration opportunities.
+
+This guide covers five complementary strategies for tracking new publications: RSS feeds from preprint servers and journals, keyword-based alerts from search engines, citation tracking for monitoring who cites your work or key papers, social and community feeds, and AI-powered discovery tools. The goal is to build a personalized monitoring pipeline that delivers relevant papers to you daily with minimal noise.
+
+Each strategy is described with setup instructions, tool recommendations, and configuration tips so you can have a working tracking system within an afternoon.
+
+## RSS Feeds from Preprint Servers
+
+RSS remains the most reliable method for monitoring preprint servers like arXiv, bioRxiv, and SSRN.
+
+### arXiv RSS Setup
+
+arXiv provides RSS feeds for every category and subcategory:
+
+```
+# Feed URL format
+https://rss.arxiv.org/rss/{category}
+
+# Examples
+https://rss.arxiv.org/rss/cs.CL    # Computation and Language
+https://rss.arxiv.org/rss/cs.LG    # Machine Learning
+https://rss.arxiv.org/rss/stat.ML  # Statistics: Machine Learning
+https://rss.arxiv.org/rss/q-bio.GN # Genomics
+```
+
+### bioRxiv and medRxiv
+
+```
+# bioRxiv new papers by subject
+https://connect.biorxiv.org/biorxiv_xml.php?subject=neuroscience
+
+# medRxiv new papers
+https://connect.medrxiv.org/medrxiv_xml.php?subject=epidemiology
+```
+
+### Recommended RSS Readers
+
+| Reader | Platform | Free Tier | Best Feature |
+|--------|----------|-----------|-------------|
+| Feedly | Web/Mobile | 100 feeds | AI prioritization |
+| Inoreader | Web/Mobile | 150 feeds | Rules & filters |
+| Miniflux | Self-hosted | Unlimited | Full control |
+| NetNewsWire | macOS/iOS | Unlimited | Native, fast, open-source |
+| Feedbin | Web | Paid only | Clean interface |
+
+### Filtering High-Volume Feeds
+
+For categories with 50+ daily papers, set up keyword filters in your RSS reader:
+
+```
+# Inoreader rule example
+IF title contains "transformer" OR "attention mechanism"
+AND title does NOT contain "survey" OR "review"
+THEN star AND move to "Priority" folder
+```
+
+## Keyword-Based Alerts
+
+### Google Scholar Alerts
+
+1. Go to [scholar.google.com/scholar_alerts](https://scholar.google.com/scholar_alerts)
+2. Click "Create alert"
+3. Enter a search query using operators:
+
+```
+# Specific phrase
+"graph neural network" "drug discovery"
+
+# Author tracking
+author:"Yoshua Bengio"
+
+# Venue-specific
+source:"Nature Machine Intelligence"
+```
+
+Tips:
+- Create 5-10 focused alerts rather than 1-2 broad ones.
+- Use quotation marks for exact phrases.
+- Review and refine alerts monthly.
+
+### Semantic Scholar Alerts
+
+Semantic Scholar offers research feed customization:
+
+1. Create an account at [semanticscholar.org](https://www.semanticscholar.org/)
+2. Add papers to your library
+3. The recommendation engine learns your interests
+4. Enable weekly email digest
+
+### PubMed Alerts (Biomedical)
+
+```
+# Create a saved search at pubmed.ncbi.nlm.nih.gov
+# Example query with MeSH terms
+("machine learning"[MeSH] OR "deep learning"[MeSH])
+AND "drug discovery"[MeSH]
+AND "2024/01/01"[Date - Publication] : "3000"[Date - Publication]
+
+# Set up email alerts: Save search > Create alert > Weekly
+```
+
+## Citation Tracking
+
+Citation tracking answers: "Who is building on this foundational paper?"
+
+### Methods
+
+| Method | Coverage | Real-time | Cost |
+|--------|----------|-----------|------|
+| Google Scholar "Cited by" alerts | Broad | Near real-time | Free |
+| Semantic Scholar citation alerts | CS, biomedical | Weekly | Free |
+| Web of Science citation reports | Comprehensive | Weekly | Institutional |
+| Scopus citation alerts | Comprehensive | Configurable | Institutional |
+| ResearchGate notifications | Author-based | Real-time | Free |
+
+### Setting Up Google Scholar Citation Alerts
+
+1. Search for the paper on Google Scholar.
+2. Click "Cited by N" below the paper.
+3. Click the envelope icon ("Create alert") at the top of the results page.
+4. Receive an email whenever a new paper cites the tracked paper.
+
+### Tracking Your Own Citations
+
+1. Create a [Google Scholar Profile](https://scholar.google.com/intl/en/scholar/citations.html).
+2. Verify your papers.
+3. Enable "New citations to my articles" alerts.
+4. Monitor your h-index and i10-index trends.
+
+## AI-Powered Discovery Tools
+
+### Connected Papers
+
+[connectedpapers.com](https://connectedpapers.com/) builds a visual graph of related papers:
+
+1. Enter a seed paper (title, DOI, or URL).
+2. The tool generates a similarity graph (not citation graph).
+3. Papers that are close together share more conceptual similarity.
+4. Use "Prior works" and "Derivative works" views for temporal exploration.
+
+### Elicit
+
+[elicit.com](https://elicit.com/) uses language models to search and summarize papers:
+
+1. Ask a natural-language research question.
+2. Elicit finds relevant papers and extracts key findings.
+3. Use the "Columns" feature to compare methods, datasets, and results across papers.
+
+### Research Rabbit
+
+[researchrabbit.ai](https://www.researchrabbit.ai/) provides:
+
+- Citation network visualization
+- "Similar work" recommendations
+- Author network exploration
+- Collection-based monitoring with email alerts
+
+## Building Your Daily Pipeline
+
+A recommended daily reading workflow:
+
+```
+Morning (15 min):
+1. Check RSS reader for new preprints (filtered by keywords)
+2. Star 3-5 papers for reading later
+3. Quick-scan abstracts of starred papers
+
+Weekly (1 hour):
+1. Read 2-3 starred papers in full
+2. Add to Zotero with tags and notes
+3. Check citation alerts for tracked papers
+4. Review AI recommendations (Semantic Scholar, Research Rabbit)
+
+Monthly (30 min):
+1. Audit alert quality -- prune noisy alerts, add new ones
+2. Update RSS feed subscriptions for evolving interests
+3. Share interesting papers with lab group
+```
+
+## Best Practices
+
+- **Limit your feeds.** It is better to thoroughly read 5 papers per week than to skim 50.
+- **Use a reference manager from day one.** Zotero, Paperpile, or Mendeley -- pick one and use it consistently.
+- **Tag papers by project.** When you start writing, you will need to find that paper you read six months ago.
+- **Share with your team.** Set up a shared Zotero group or Slack channel for paper recommendations.
+- **Track trends, not just individual papers.** Notice when multiple groups independently converge on the same idea.
+- **Combine automated and social discovery.** Algorithms miss papers that colleagues recommend.
+
+## References
+
+- [arXiv RSS Feeds](https://info.arxiv.org/help/rss.html) -- Official arXiv RSS documentation
+- [Google Scholar Alerts](https://scholar.google.com/scholar_alerts) -- Citation and keyword alerts
+- [Semantic Scholar](https://www.semanticscholar.org/) -- AI-powered paper search
+- [Connected Papers](https://www.connectedpapers.com/) -- Visual paper exploration
+- [Research Rabbit](https://www.researchrabbit.ai/) -- Collection-based paper discovery

package/skills/literature/discovery/rss-paper-feeds/SKILL.md

@@ -0,0 +1,214 @@
+---
+name: rss-paper-feeds
+description: "Set up RSS feeds and alerts to track new publications in your research area"
+metadata:
+  openclaw:
+    emoji: "bell"
+    category: "literature"
+    subcategory: "discovery"
+    keywords: ["RSS feed", "new publication tracking", "literature alert", "citation notification", "research monitoring"]
+    source: "wentor"
+---
+
+# RSS Paper Feeds
+
+A skill for configuring automated literature monitoring using RSS feeds, email alerts, and citation notifications. Stay current with new publications in your research area without manual searching.
+
+## RSS Feed Sources for Academic Papers
+
+### Journal-Level Feeds
+
+Most major publishers provide RSS feeds for their journals:
+
+| Publisher | Feed URL Pattern | Example |
+|-----------|-----------------|---------|
+| Nature | `https://www.nature.com/[journal].rss` | `nature.com/nature.rss` |
+| Science | `https://www.science.org/action/showFeed?type=etoc&feed=rss&jc=[code]` | jc=science |
+| Elsevier | `https://rss.sciencedirect.com/publication/science/[ISSN]` | ISSN 0004-3702 for AI |
+| Springer | `https://link.springer.com/search.rss?search-within=Journal&facet-journal-id=[id]` | id=10994 |
+| IEEE | `https://ieeexplore.ieee.org/rss/TOC[journal_number].XML` | |
+| arXiv | `https://rss.arxiv.org/rss/[category]` | cs.AI, stat.ML |
+
+### Setting Up arXiv Feeds
+
+```python
+import feedparser
+from datetime import datetime
+
+def fetch_arxiv_feed(categories: list[str], max_results: int = 50) -> list[dict]:
+    """
+    Fetch recent papers from arXiv RSS feeds.
+
+    Args:
+        categories: List of arXiv categories (e.g., ['cs.AI', 'cs.CL', 'stat.ML'])
+        max_results: Maximum number of papers to return
+    """
+    all_papers = []
+
+    for category in categories:
+        feed_url = f"https://rss.arxiv.org/rss/{category}"
+        feed = feedparser.parse(feed_url)
+
+        for entry in feed.entries[:max_results]:
+            all_papers.append({
+                'title': entry.title.strip(),
+                'authors': entry.get('author', 'Unknown'),
+                'abstract': entry.get('summary', '')[:500],
+                'link': entry.link,
+                'category': category,
+                'published': entry.get('published', ''),
+                'arxiv_id': entry.link.split('/')[-1] if entry.link else ''
+            })
+
+    # Deduplicate (papers may appear in multiple categories)
+    seen = set()
+    unique = []
+    for p in all_papers:
+        if p['arxiv_id'] not in seen:
+            seen.add(p['arxiv_id'])
+            unique.append(p)
+
+    return unique[:max_results]
+
+# Example: monitor AI and NLP papers
+papers = fetch_arxiv_feed(['cs.AI', 'cs.CL', 'cs.LG'], max_results=30)
+for p in papers[:5]:
+    print(f"[{p['category']}] {p['title']}")
+    print(f"  {p['link']}\n")
+```
+
+## Citation Alerts
+
+### Google Scholar Citations Alert
+
+```
+Setup:
+1. Search for your key reference papers on Google Scholar
+2. Click the "Cited by N" link under each paper
+3. Click the envelope icon ("Create alert") at the top of results
+4. Enter your email address
+5. You will receive notifications when new papers cite that work
+
+Recommended: Set alerts for:
+- Your own publications (track who cites you)
+- 5-10 foundational papers in your field
+- Key competitor or collaborator publications
+```
+
+### Semantic Scholar Alerts API
+
+```python
+import requests
+
+def setup_semantic_scholar_alert(paper_id: str, email: str) -> dict:
+    """
+    Monitor citations for a specific paper via Semantic Scholar.
+
+    Args:
+        paper_id: Semantic Scholar paper ID or DOI
+        email: Email for notifications
+    """
+    # Fetch current citation count for baseline
+    response = requests.get(
+        f"https://api.semanticscholar.org/graph/v1/paper/{paper_id}",
+        params={'fields': 'title,citationCount,citations.title,citations.year'}
+    )
+    data = response.json()
+
+    return {
+        'paper': data.get('title', ''),
+        'current_citations': data.get('citationCount', 0),
+        'recent_citations': [
+            c for c in data.get('citations', [])
+            if c.get('year', 0) >= datetime.now().year - 1
+        ][:10],
+        'alert_email': email,
+        'status': 'configured'
+    }
+```
+
+## RSS Reader Configuration
+
+### Recommended RSS Readers for Researchers
+
+| Reader | Platform | Features | Cost |
+|--------|----------|----------|------|
+| Feedly | Web/mobile | AI summaries, boards, teams | Free tier + Pro $8/mo |
+| Inoreader | Web/mobile | Rules, filters, monitoring | Free tier + Pro $5/mo |
+| Zotero RSS | Desktop | Integrated with reference manager | Free |
+| Thunderbird | Desktop | Email + RSS in one client | Free |
+| Miniflux | Self-hosted | Minimal, fast, API | Free (self-hosted) |
+
+### Organizing Feeds Effectively
+
+```yaml
+feed_organization:
+  folders:
+    core_journals:
+      description: "Top journals in my primary field"
+      feeds: 5-8
+      check_frequency: "daily"
+
+    broad_monitoring:
+      description: "Adjacent fields and high-impact general journals"
+      feeds: 10-15
+      check_frequency: "weekly"
+
+    preprints:
+      description: "arXiv categories and SSRN feeds"
+      feeds: 3-5
+      check_frequency: "daily"
+
+    citation_alerts:
+      description: "New citations of key papers"
+      feeds: 10-20
+      check_frequency: "weekly"
+
+  workflow:
+    daily: "Scan titles in core_journals and preprints (10 min)"
+    weekly: "Review broad_monitoring and citation_alerts (30 min)"
+    monthly: "Audit feed list, remove low-value feeds, add new ones"
+```
+
+## Automated Filtering and Summarization
+
+### Keyword-Based Paper Filtering
+
+```python
+def filter_papers(papers: list[dict], keywords: list[str],
+                   title_weight: float = 3.0,
+                   abstract_weight: float = 1.0,
+                   threshold: float = 2.0) -> list[dict]:
+    """
+    Score and filter papers by relevance to your research keywords.
+
+    Args:
+        papers: List of paper dicts with 'title' and 'abstract'
+        keywords: Your research keywords
+        title_weight: Weight multiplier for title matches
+        abstract_weight: Weight multiplier for abstract matches
+        threshold: Minimum relevance score to include
+    """
+    scored = []
+    for paper in papers:
+        score = 0
+        title_lower = paper.get('title', '').lower()
+        abstract_lower = paper.get('abstract', '').lower()
+
+        for kw in keywords:
+            kw_lower = kw.lower()
+            if kw_lower in title_lower:
+                score += title_weight
+            if kw_lower in abstract_lower:
+                score += abstract_weight
+
+        if score >= threshold:
+            paper['relevance_score'] = score
+            scored.append(paper)
+
+    return sorted(scored, key=lambda x: x['relevance_score'], reverse=True)
+```
+
+## Integration with Reference Managers
+
+Configure your RSS reader to send relevant papers directly to your reference manager (Zotero, Mendeley, or EndNote). Most readers support "Save to Zotero" browser extensions or IFTTT/Zapier integrations for automated workflows. This creates a seamless pipeline from discovery to organized storage.

package/skills/literature/discovery/semantic-scholar-recs-guide/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: semantic-scholar-recs-guide
+description: "Using Semantic Scholar recommendations API for paper discovery"
+metadata:
+  openclaw:
+    emoji: "ai"
+    category: "literature"
+    subcategory: "discovery"
+    keywords: ["related papers", "literature recommendation", "paper discovery", "citation network"]
+    source: "wentor-research-plugins"
+---
+
+# Semantic Scholar Recommendations Guide
+
+Leverage the Semantic Scholar (S2) API to discover related papers, traverse citation networks, and build comprehensive reading lists programmatically.
+
+## Overview
+
+Semantic Scholar indexes over 200 million academic papers and provides a free, rate-limited API that supports:
+
+- Paper search by title, keyword, or DOI
+- Recommendations based on positive and negative seed papers
+- Citation and reference graph traversal
+- Author profiles and publication histories
+- Bulk data access for large-scale analyses
+
+Base URL: `https://api.semanticscholar.org/graph/v1`
+Recommendations endpoint: `https://api.semanticscholar.org/recommendations/v1`
+
+## Getting Recommendations from Seed Papers
+
+The recommendations endpoint accepts a list of positive (and optionally negative) paper IDs and returns related papers ranked by relevance.
+
+### Single-Paper Recommendations
+
+```python
+import requests
+
+PAPER_ID = "649def34f8be52c8b66281af98ae884c09aef38b"  # SHA or S2 ID
+
+response = requests.get(
+    f"https://api.semanticscholar.org/recommendations/v1/papers/forpaper/{PAPER_ID}",
+    params={
+        "fields": "title,authors,year,citationCount,abstract,externalIds",
+        "limit": 20
+    },
+    headers={"x-api-key": "YOUR_API_KEY"}  # optional, increases rate limit
+)
+
+for paper in response.json()["recommendedPapers"]:
+    print(f"[{paper['year']}] {paper['title']} (citations: {paper['citationCount']})")
+```
+
+### Multi-Paper Recommendations (Positive + Negative Seeds)
+
+```python
+import requests
+
+payload = {
+    "positivePaperIds": [
+        "649def34f8be52c8b66281af98ae884c09aef38b",
+        "ARXIV:2005.14165"  # can use arXiv ID prefix
+    ],
+    "negativePaperIds": [
+        "ArXiv:1706.03762"  # exclude attention-is-all-you-need style papers
+    ]
+}
+
+response = requests.post(
+    "https://api.semanticscholar.org/recommendations/v1/papers/",
+    json=payload,
+    params={"fields": "title,year,citationCount,url,abstract", "limit": 30}
+)
+
+results = response.json()["recommendedPapers"]
+print(f"Found {len(results)} recommended papers")
+```
+
+## Citation Network Traversal
+
+Walk the citation graph to discover foundational and derivative works.
+
+### Forward Citations (Who Cited This Paper?)
+
+```python
+paper_id = "649def34f8be52c8b66281af98ae884c09aef38b"
+
+response = requests.get(
+    f"https://api.semanticscholar.org/graph/v1/paper/{paper_id}/citations",
+    params={
+        "fields": "title,year,citationCount,authors",
+        "limit": 100,
+        "offset": 0
+    }
+)
+
+citations = response.json()["data"]
+# Sort by citation count to find most influential derivative works
+citations.sort(key=lambda x: x["citingPaper"]["citationCount"], reverse=True)
+for c in citations[:10]:
+    p = c["citingPaper"]
+    print(f"  [{p['year']}] {p['title']} ({p['citationCount']} cites)")
+```
+
+### Backward References (What Did This Paper Cite?)
+
+```python
+response = requests.get(
+    f"https://api.semanticscholar.org/graph/v1/paper/{paper_id}/references",
+    params={"fields": "title,year,citationCount,authors", "limit": 100}
+)
+
+refs = response.json()["data"]
+refs.sort(key=lambda x: x["citedPaper"]["citationCount"], reverse=True)
+```
+
+## Building a Reading List Pipeline
+
+Combine search, recommendations, and citation traversal into a discovery pipeline:
+
+| Step | Method | Purpose |
+|------|--------|---------|
+| 1. Seed selection | Manual or keyword search | Identify 3-5 highly relevant papers |
+| 2. Expand via recs | Multi-paper recommendations | Find thematically related work |
+| 3. Forward citation | Citations endpoint | Find recent derivative works |
+| 4. Backward citation | References endpoint | Find foundational papers |
+| 5. Deduplicate | S2 paper ID matching | Remove duplicates across steps |
+| 6. Rank & filter | Sort by year, citations, relevance | Prioritize reading order |
+
+```python
+def build_reading_list(seed_ids, max_papers=50):
+    """Build a ranked reading list from seed papers."""
+    seen = set()
+    candidates = []
+
+    # Step 1: Get recommendations
+    recs = get_recommendations(seed_ids)
+    for paper in recs:
+        if paper["paperId"] not in seen:
+            seen.add(paper["paperId"])
+            candidates.append(paper)
+
+    # Step 2: Get citations of seed papers
+    for sid in seed_ids:
+        cites = get_citations(sid, limit=50)
+        for c in cites:
+            pid = c["citingPaper"]["paperId"]
+            if pid not in seen:
+                seen.add(pid)
+                candidates.append(c["citingPaper"])
+
+    # Step 3: Rank by citation count and recency
+    candidates.sort(key=lambda p: (p.get("year", 0), p.get("citationCount", 0)), reverse=True)
+    return candidates[:max_papers]
+```
+
+## Rate Limits and Best Practices
+
+- **Without API key**: 100 requests per 5 minutes
+- **With API key**: 1 request/second sustained (request a key at semanticscholar.org/product/api)
+- Always include only the fields you need to reduce payload size
+- Use `offset` and `limit` for pagination on large result sets
+- Cache responses locally to avoid redundant requests
+- Use DOI, arXiv ID, or PubMed ID as paper identifiers for cross-system compatibility (prefix with `DOI:`, `ARXIV:`, or `PMID:`)