@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/research/methodology/osf-api-guide/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: osf-api-guide
+description: "Access Open Science Framework for preregistrations, preprints, and data"
+metadata:
+  openclaw:
+    emoji: "🔓"
+    category: "research"
+    subcategory: "methodology"
+    keywords: ["osf", "open-science", "preregistration", "preprints", "reproducibility", "collaboration"]
+    source: "https://developer.osf.io/"
+---
+
+# OSF (Open Science Framework) API Guide
+
+## Overview
+
+The Open Science Framework (OSF) is a free, open-source platform developed by the Center for Open Science (COS) that supports the entire research lifecycle. It provides tools for project management, preregistration of studies, data storage, preprint hosting, and research collaboration. OSF is widely used across social sciences, psychology, and increasingly in other disciplines as a hub for transparent and reproducible research.
+
+The OSF API v2 is a JSON:API-compliant RESTful interface that provides programmatic access to the full range of OSF features. Researchers can search for preregistrations, browse preprints hosted on OSF Preprints and its community servers (such as PsyArXiv, SocArXiv, and BioHackrXiv), access project files and metadata, and manage their own research projects.
+
+Public data on OSF is accessible without authentication. Creating or modifying resources requires a personal access token. The API is free for all users.
+
+## Authentication
+
+Public read access requires no authentication. For creating or modifying resources, generate a personal access token at https://osf.io/settings/tokens.
+
+```bash
+# Public access (no auth needed)
+curl "https://api.osf.io/v2/nodes/?filter[title]=reproducibility"
+
+# Authenticated access for write operations
+export OSF_TOKEN=$OSF_TOKEN
+curl -H "Authorization: Bearer $OSF_TOKEN" \
+  "https://api.osf.io/v2/users/me/"
+```
+
+## Core Endpoints
+
+### Search Nodes (Projects)
+
+Find public OSF projects by title, tags, or other attributes.
+
+```
+GET https://api.osf.io/v2/nodes/?filter[title]={query}
+```
+
+**Parameters:**
+- `filter[title]`: Filter by project title (contains match)
+- `filter[tags]`: Filter by tags
+- `filter[category]`: Filter by category (project, data, analysis, etc.)
+- `page[size]`: Results per page (default 10, max 100)
+- `page`: Page number
+
+**Example: Search for replication studies:**
+
+```bash
+curl -s "https://api.osf.io/v2/nodes/?filter[title]=replication&page[size]=5" \
+  | python3 -m json.tool
+```
+
+### Search Preprints
+
+Browse preprints across OSF and its community preprint servers.
+
+```
+GET https://api.osf.io/v2/preprints/?filter[provider]={provider}
+```
+
+```bash
+curl -s "https://api.osf.io/v2/preprints/?filter[provider]=psyarxiv&page[size]=5" \
+  | python3 -m json.tool
+```
+
+### Get Preregistrations
+
+Search for preregistered studies, a cornerstone of open science methodology.
+
+```
+GET https://api.osf.io/v2/registrations/?filter[title]={query}
+```
+
+```bash
+curl -s "https://api.osf.io/v2/registrations/?filter[title]=cognitive+bias&page[size]=5" \
+  | python3 -m json.tool
+```
+
+### Python Example: Analyze Preregistration Trends
+
+```python
+import requests
+import time
+
+BASE_URL = "https://api.osf.io/v2"
+
+def search_registrations(query, max_pages=5):
+    """Search OSF registrations (preregistered studies)."""
+    all_results = []
+    url = f"{BASE_URL}/registrations/"
+    params = {
+        "filter[title]": query,
+        "page[size]": 25,
+        "page": 1
+    }
+
+    for page_num in range(1, max_pages + 1):
+        params["page"] = page_num
+        resp = requests.get(url, params=params)
+        data = resp.json()
+        results = data.get("data", [])
+        if not results:
+            break
+        all_results.extend(results)
+        time.sleep(0.5)
+
+    return all_results
+
+registrations = search_registrations("randomized controlled trial")
+print(f"Found {len(registrations)} preregistrations")
+
+for reg in registrations[:5]:
+    attrs = reg.get("attributes", {})
+    print(f"  Title: {attrs.get('title')}")
+    print(f"  Created: {attrs.get('date_created', '')[:10]}")
+    print(f"  Category: {attrs.get('category')}")
+    print(f"  Public: {attrs.get('public')}")
+    print("---")
+```
+
+### Get Project Files
+
+List files attached to an OSF project node.
+
+```bash
+curl -s "https://api.osf.io/v2/nodes/{node_id}/files/osfstorage/" \
+  | python3 -m json.tool
+```
+
+## Common Research Patterns
+
+**Preregistration Review:** Search for preregistered studies in your field to understand how others formulate hypotheses, specify sample sizes, and plan analyses before data collection. This is essential for meta-science and methodological research.
+
+**Preprint Discovery:** Use the preprints endpoint to find the latest unrefereed manuscripts across multiple community servers, getting access to cutting-edge findings before formal publication.
+
+**Open Data Access:** Retrieve datasets attached to OSF projects for replication attempts, secondary analyses, or meta-analyses. OSF projects often include raw data, analysis scripts, and materials.
+
+**Collaboration Mapping:** Explore contributors and linked projects to understand research collaboration networks in specific domains.
+
+**Reproducibility Audits:** Programmatically check whether published studies have associated preregistrations, open data, or open materials on OSF.
+
+## Rate Limits and Best Practices
+
+- **Rate limit:** 100 requests per minute for unauthenticated, higher limits for authenticated requests
+- **Pagination:** Use `page` and `page[size]` parameters; default page size is 10
+- **JSON:API format:** Responses follow JSON:API specification; data is under the `data` key, relationships are linked
+- **Sparse fieldsets:** Use `fields[nodes]=title,date_created` to request only needed fields
+- **Embedding:** Use `embed=contributors` to include related resources in a single request
+- **Respect the service:** Add delays between rapid sequential requests; use the `links.next` URL for pagination
+
+## References
+
+- OSF API v2 Documentation: https://developer.osf.io/
+- OSF Platform: https://osf.io/
+- OSF Preprints: https://osf.io/preprints/
+- OSF Registrations (Preregistration): https://osf.io/registries/
+- Center for Open Science: https://www.cos.io/

package/skills/research/methodology/parsifal-slr-guide/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: parsifal-slr-guide
+description: "Plan and manage systematic literature reviews with Parsifal platform"
+metadata:
+  openclaw:
+    emoji: "📋"
+    category: "research"
+    subcategory: "methodology"
+    keywords: ["Parsifal", "systematic review", "SLR", "review protocol", "PICO", "research methodology"]
+    source: "https://github.com/vitorfs/parsifal"
+---
+
+# Parsifal Systematic Literature Review Guide
+
+## Overview
+
+Parsifal is a web-based tool for planning and managing systematic literature reviews (SLRs) following established protocols (Kitchenham, PRISMA). It guides researchers through the complete SLR process: defining research questions, setting inclusion/exclusion criteria, planning search strings, and tracking the screening process. Open-source and self-hostable.
+
+## SLR Process with Parsifal
+
+### Phase 1: Planning
+
+#### Define Research Questions
+
+Structure questions using PICO framework:
+- **P**opulation: What group/domain?
+- **I**ntervention: What technique/method?
+- **C**omparison: Compared to what?
+- **O**utcome: What results measured?
+
+```
+Example:
+P: Software development teams
+I: AI-assisted code review
+C: Manual code review
+O: Defect detection rate, review time
+
+Research Questions:
+RQ1: Does AI-assisted code review improve defect detection?
+RQ2: What is the time savings compared to manual review?
+RQ3: What types of defects are best detected by AI tools?
+```
+
+#### Set Criteria
+
+```
+Inclusion Criteria:
+IC1: Studies comparing AI vs manual code review
+IC2: Published in peer-reviewed venues (2020-2026)
+IC3: Reports quantitative metrics
+
+Exclusion Criteria:
+EC1: Grey literature / blog posts
+EC2: Studies with fewer than 10 participants
+EC3: Non-English publications
+```
+
+### Phase 2: Search Strategy
+
+#### Build Search String
+
+```
+("artificial intelligence" OR "machine learning" OR "deep learning")
+AND
+("code review" OR "code inspection" OR "static analysis")
+AND
+("defect detection" OR "bug finding" OR "software quality")
+```
+
+#### Database Mapping
+
+| Database | Adapted Query | Expected Results |
+|----------|--------------|-----------------|
+| Scopus | TITLE-ABS-KEY(...) | ~500 |
+| IEEE Xplore | querytext=... | ~300 |
+| ACM DL | [[Abstract: ...]] | ~200 |
+| Web of Science | TS=(...) | ~400 |
+
+### Phase 3: Selection
+
+#### Screening Steps
+
+1. **Remove duplicates** — Match by DOI, title similarity
+2. **Title screening** — Quick relevance assessment
+3. **Abstract screening** — Apply inclusion/exclusion criteria
+4. **Full-text review** — Detailed evaluation
+
+#### Quality Assessment
+
+Define quality criteria and scoring:
+
+| Criterion | Score |
+|-----------|-------|
+| Clear research question stated | 0/0.5/1 |
+| Methodology described in detail | 0/0.5/1 |
+| Threats to validity discussed | 0/0.5/1 |
+| Results statistically analyzed | 0/0.5/1 |
+| Study replicable from description | 0/0.5/1 |
+
+### Phase 4: Extraction
+
+#### Data Extraction Form
+
+```
+For each included paper, extract:
+- Study ID
+- Authors, Year, Venue
+- Study type (experiment/case study/survey)
+- Population size
+- AI technique used
+- Metrics reported (precision, recall, F1, time)
+- Key findings
+- Limitations noted
+```
+
+### Phase 5: Synthesis
+
+#### Report with PRISMA
+
+```
+Identification: 1,400 records
+  ↓ Remove duplicates: -350
+Screening: 1,050 titles/abstracts
+  ↓ Exclude irrelevant: -900
+Eligibility: 150 full-text assessed
+  ↓ Exclude by criteria: -108
+Included: 42 studies in final review
+```
+
+## Self-Hosting Parsifal
+
+```bash
+git clone https://github.com/vitorfs/parsifal.git
+cd parsifal
+pip install -r requirements.txt
+python manage.py migrate
+python manage.py runserver
+# Access at http://localhost:8000
+```
+
+## SLR Best Practices
+
+1. **Register protocol** before starting (PROSPERO for health, OSF for others)
+2. **Two independent reviewers** for screening to reduce bias
+3. **Track inter-rater agreement** (Cohen's kappa > 0.8)
+4. **Document deviations** from the original protocol
+5. **Use PRISMA checklist** for reporting completeness
+
+## References
+
+- [Parsifal](https://github.com/vitorfs/parsifal)
+- Kitchenham, B. & Charters, S. (2007). "Guidelines for performing Systematic Literature Reviews in Software Engineering."
+- [PRISMA Statement](http://www.prisma-statement.org/)
+- [PROSPERO Registry](https://www.crd.york.ac.uk/prospero/)

package/skills/research/methodology/research-paper-kb/SKILL.md

@@ -0,0 +1,263 @@
+---
+name: research-paper-kb
+description: "Build a persistent cross-session knowledge base from academic papers"
+metadata:
+  openclaw:
+    emoji: "brain"
+    category: "research"
+    subcategory: "methodology"
+    keywords: ["knowledge base", "paper notes", "literature management", "cross-session", "research memory"]
+    source: "https://github.com/wentor-ai/research-plugins"
+---
+
+# Research Paper Knowledge Base
+
+Build and maintain a persistent, structured knowledge base from academic papers that persists across sessions. This skill enables cumulative literature understanding by storing extracted insights, cross-references, and analytical notes in a queryable format that grows with each reading session.
+
+## Overview
+
+A core challenge in literature review work is that insights from individual papers are often lost between reading sessions. Researchers read a paper, extract key findings, then move on -- only to forget critical details weeks later when writing their own manuscript or encountering a related paper. Traditional reference managers store metadata and PDFs but do not capture the analytical work of reading: the connections between papers, the critiques of methodology, the synthesis of findings across studies.
+
+This skill creates a structured knowledge base that captures not just what papers say, but how they relate to each other and to the researcher's own questions. Each paper entry includes standard metadata, section-by-section notes, methodological assessments, extracted claims with evidence quality ratings, and explicit connections to other papers in the knowledge base.
+
+The knowledge base is stored in a human-readable format (Markdown + YAML frontmatter) that can be version-controlled with git, searched with standard tools, and read by both humans and AI assistants. When returning to the literature after days or weeks, the researcher (or their AI assistant) can query the knowledge base to recall prior findings, identify gaps, and build on accumulated understanding.
+
+## Knowledge Base Structure
+
+### Directory Layout
+
+```
+research-kb/
+  _index.yaml              # Master index of all papers
+  _themes.yaml             # Cross-cutting themes and concepts
+  _questions.yaml           # Active research questions
+  papers/
+    smith-2024-deep-learning-proteins/
+      notes.md              # Structured paper notes
+      claims.yaml           # Extracted claims with evidence
+      figures/              # Saved key figures (optional)
+    jones-2023-attention-mechanisms/
+      notes.md
+      claims.yaml
+  syntheses/
+    attention-in-biology.md  # Cross-paper synthesis documents
+    methodology-comparison.md
+```
+
+### Paper Notes Template
+
+```markdown
+---
+paper_id: smith-2024-deep-learning-proteins
+title: "Deep Learning for Protein Structure Prediction: A Survey"
+authors: ["Smith, J.", "Chen, L.", "Williams, R."]
+year: 2024
+venue: "Nature Reviews Molecular Cell Biology"
+doi: "10.1038/s41580-024-00001-1"
+date_read: "2026-03-10"
+relevance: high
+tags: ["protein structure", "deep learning", "AlphaFold", "survey"]
+connections: ["jones-2023-attention-mechanisms", "brown-2022-alphafold2"]
+---
+
+# Deep Learning for Protein Structure Prediction: A Survey
+
+## Reading Purpose
+Why I read this paper and what questions I hoped it would answer.
+
+## Summary
+2-3 paragraph summary of the paper's main argument and contribution.
+
+## Key Findings
+1. **Finding 1**: Description with page/section reference (p. 5, Section 3.2)
+2. **Finding 2**: Description
+3. **Finding 3**: Description
+
+## Methodology Assessment
+- **Approach**: Survey/review methodology
+- **Scope**: 200+ papers covering 2018-2024
+- **Strengths**: Comprehensive taxonomy of approaches, clear evaluation framework
+- **Weaknesses**: Limited coverage of non-English literature, no meta-analysis
+- **Reproducibility**: N/A (review paper)
+
+## Connections to My Research
+- Directly relevant to [my research question] because...
+- Contradicts/supports [finding from another paper] in that...
+- Suggests new direction: ...
+
+## Key Quotes
+> "Quote 1" (p. X)
+> "Quote 2" (p. Y)
+
+## Questions Raised
+- [ ] Follow up on the claim that X leads to Y (cited as [ref])
+- [ ] Check whether the benchmark in Table 3 includes recent models
+- [ ] Read the methodological critique in [cited paper]
+
+## References to Chase
+- [Author, Year]: Reason this reference seems important
+- [Author, Year]: Potential counterargument to main thesis
+```
+
+### Claims Database
+
+```yaml
+# claims.yaml - Extracted claims with evidence quality
+claims:
+  - id: smith-2024-claim-01
+    statement: "AlphaFold2 achieves experimental-level accuracy on 95% of CASP14 targets"
+    evidence_type: "empirical"
+    evidence_quality: "strong"  # strong | moderate | weak | anecdotal
+    page: 8
+    section: "3.1"
+    supports: ["brown-2022-claim-03"]
+    contradicts: []
+    caveats: "Accuracy measured by GDT-TS; performance varies for disordered regions"
+
+  - id: smith-2024-claim-02
+    statement: "Attention mechanisms are the key architectural innovation enabling structure prediction"
+    evidence_type: "analytical"
+    evidence_quality: "moderate"
+    page: 12
+    section: "4.2"
+    supports: ["jones-2023-claim-01"]
+    contradicts: ["lee-2023-claim-05"]
+    caveats: "Author's interpretation; alternative architectures not fully explored"
+```
+
+## Building the Knowledge Base
+
+### Adding a Paper
+
+```python
+import yaml
+from pathlib import Path
+from datetime import date
+
+def add_paper(kb_path, paper_id, metadata, notes):
+    """Add a new paper to the knowledge base."""
+    paper_dir = Path(kb_path) / "papers" / paper_id
+    paper_dir.mkdir(parents=True, exist_ok=True)
+
+    # Write notes.md with YAML frontmatter
+    frontmatter = yaml.dump(metadata, default_flow_style=False)
+    content = f"---\n{frontmatter}---\n\n{notes}"
+
+    (paper_dir / "notes.md").write_text(content)
+
+    # Update master index
+    update_index(kb_path, paper_id, metadata)
+
+    print(f"Added paper: {paper_id}")
+
+def update_index(kb_path, paper_id, metadata):
+    """Update the master index with new paper."""
+    index_path = Path(kb_path) / "_index.yaml"
+    if index_path.exists():
+        index = yaml.safe_load(index_path.read_text()) or {}
+    else:
+        index = {"papers": {}}
+
+    index["papers"][paper_id] = {
+        "title": metadata["title"],
+        "year": metadata["year"],
+        "relevance": metadata.get("relevance", "medium"),
+        "tags": metadata.get("tags", []),
+        "date_added": str(date.today())
+    }
+
+    index_path.write_text(yaml.dump(index, default_flow_style=False))
+```
+
+### Querying the Knowledge Base
+
+```python
+def find_papers_by_tag(kb_path, tag):
+    """Find all papers with a given tag."""
+    index = yaml.safe_load((Path(kb_path) / "_index.yaml").read_text())
+    results = []
+    for paper_id, info in index["papers"].items():
+        if tag in info.get("tags", []):
+            results.append((paper_id, info["title"]))
+    return results
+
+def find_connections(kb_path, paper_id):
+    """Find all papers connected to a given paper."""
+    paper_dir = Path(kb_path) / "papers" / paper_id
+    notes_path = paper_dir / "notes.md"
+    content = notes_path.read_text()
+
+    # Parse YAML frontmatter
+    parts = content.split("---", 2)
+    metadata = yaml.safe_load(parts[1])
+
+    return metadata.get("connections", [])
+
+def get_claims_supporting(kb_path, claim_id):
+    """Find all claims that support a given claim."""
+    results = []
+    for claims_file in Path(kb_path).rglob("claims.yaml"):
+        data = yaml.safe_load(claims_file.read_text())
+        for claim in data.get("claims", []):
+            if claim_id in claim.get("supports", []):
+                results.append(claim)
+    return results
+```
+
+## Cross-Session Workflow
+
+### Session Start Protocol
+
+When beginning a new reading or writing session, the AI assistant should:
+
+1. Load the master index to understand what has been read
+2. Check active research questions in `_questions.yaml`
+3. Review the most recent synthesis documents
+4. Identify papers flagged for follow-up in previous sessions
+
+### Session End Protocol
+
+At the end of each session:
+
+1. Update notes for any papers read during the session
+2. Add new connections discovered between papers
+3. Update research questions (answer resolved ones, add new ones)
+4. Flag any papers to chase in the next session
+5. Commit changes to git with a session summary message
+
+## Synthesis Generation
+
+### Theme-Based Synthesis
+
+```markdown
+# Synthesis: Attention Mechanisms in Biology
+
+## Theme Overview
+How attention mechanisms from NLP have been adapted for biological sequence analysis.
+
+## Contributing Papers
+1. smith-2024: Survey covering 200+ papers on protein structure prediction
+2. jones-2023: Original attention mechanism analysis
+3. brown-2022: AlphaFold2 architecture deep dive
+
+## Consensus Findings
+- Attention enables capturing long-range dependencies in sequences
+- Multi-head attention is more effective than single-head for structural prediction
+- Pre-training on large unlabeled sequence databases is critical
+
+## Contested Points
+- Whether attention maps are interpretable (smith-2024 says yes, lee-2023 says no)
+- Optimal number of attention heads (ranges from 8 to 64 in literature)
+
+## Gaps in the Literature
+- Limited comparison with non-attention architectures on equal compute budgets
+- Few studies on attention for RNA structure prediction
+- No theoretical analysis of why attention works for biological sequences
+```
+
+## References
+
+- Obsidian knowledge management: https://obsidian.md
+- Zettlekasten method: https://zettelkasten.de/introduction
+- Notion for research: https://www.notion.so/templates/research
+- YAML specification: https://yaml.org/spec/1.2.2/