@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/domains/cs/gaussian-splatting-papers-guide/SKILL.md

@@ -0,0 +1,158 @@
+---
+name: gaussian-splatting-papers-guide
+description: "Curated papers and resources for 3D Gaussian Splatting"
+metadata:
+  openclaw:
+    emoji: "🔮"
+    category: "domains"
+    subcategory: "cs"
+    keywords: ["3D Gaussian Splatting", "3DGS", "neural rendering", "NeRF", "novel view synthesis", "point cloud"]
+    source: "https://github.com/MrNeRF/awesome-3D-gaussian-splatting"
+---
+
+# 3D Gaussian Splatting Papers Guide
+
+## Overview
+
+3D Gaussian Splatting (3DGS) is a breakthrough technique for real-time radiance field rendering that represents scenes as collections of 3D Gaussians. This curated collection tracks the rapidly evolving 3DGS literature — from the original paper through extensions for dynamic scenes, generation, compression, SLAM, avatars, and more. Essential for researchers in computer vision, graphics, and neural rendering.
+
+## Core Paper
+
+```bibtex
+@inproceedings{kerbl3Dgaussians,
+  title={3D Gaussian Splatting for Real-Time Radiance Field Rendering},
+  author={Kerbl, Bernhard and Kopanas, Georgios and Leimk{\"u}hler, Thomas
+          and Drettakis, George},
+  booktitle={ACM SIGGRAPH 2023},
+  year={2023}
+}
+```
+
+### Key Idea
+
+```
+Input: Multi-view images + SfM point cloud
+  ↓
+Initialize 3D Gaussians (position, covariance, color, opacity)
+  ↓
+Differentiable splatting (project Gaussians → image plane)
+  ↓
+Optimize via photometric loss
+  ↓
+Adaptive density control (clone, split, prune)
+  ↓
+Output: Real-time renderable 3D scene (100+ FPS)
+```
+
+## Research Landscape
+
+### Category Map
+
+| Category | Focus | Key Papers |
+|----------|-------|------------|
+| **Static Scenes** | Quality, compression, anti-aliasing | Mip-Splatting, Compact3D |
+| **Dynamic Scenes** | Deformable, 4D, temporal | Dynamic3DGS, 4DGS, Deformable3DGS |
+| **Generation** | Text/image to 3D | DreamGaussian, GaussianDreamer, LGM |
+| **SLAM** | Real-time mapping | SplaTAM, Gaussian-SLAM, MonoGS |
+| **Avatars** | Human body/face | GaussianAvatar, HUGS, SplatFace |
+| **Autonomous Driving** | Street scenes | StreetGaussians, DriveGS |
+| **Compression** | Storage efficiency | LightGaussian, CompGS |
+| **Editing** | Scene manipulation | GaussianEditor, GSEditor |
+| **Physics** | Simulation, deformation | PhysGaussian, Gaussian Splashing |
+| **Language** | 3D understanding | LangSplat, LEGaussians |
+
+## Tracking New Papers
+
+```python
+import requests
+from datetime import datetime, timedelta
+
+# Search arXiv for recent 3DGS papers
+def search_3dgs_papers(days_back=7):
+    """Find recent 3D Gaussian Splatting papers on arXiv."""
+    import arxiv
+
+    query = (
+        "ti:gaussian splatting OR "
+        "abs:3D gaussian splatting OR "
+        "abs:3DGS"
+    )
+
+    search = arxiv.Search(
+        query=query,
+        max_results=50,
+        sort_by=arxiv.SortCriterion.SubmittedDate,
+    )
+
+    cutoff = datetime.now() - timedelta(days=days_back)
+    papers = []
+    for result in search.results():
+        if result.published.replace(tzinfo=None) > cutoff:
+            papers.append({
+                "title": result.title,
+                "authors": [a.name for a in result.authors[:3]],
+                "url": result.entry_id,
+                "published": result.published.strftime("%Y-%m-%d"),
+                "categories": result.categories,
+            })
+    return papers
+
+recent = search_3dgs_papers(days_back=14)
+for p in recent:
+    print(f"[{p['published']}] {p['title']}")
+    print(f"  {', '.join(p['authors'])} | {p['url']}")
+```
+
+## Key Methods Comparison
+
+```python
+# Performance comparison (from original benchmarks)
+methods = {
+    "NeRF": {"psnr": 31.01, "fps": 0.03, "train_time": "hours"},
+    "Instant-NGP": {"psnr": 33.18, "fps": 9.43, "train_time": "5 min"},
+    "3DGS": {"psnr": 33.31, "fps": 134, "train_time": "6 min"},
+    "Mip-Splatting": {"psnr": 33.46, "fps": 120, "train_time": "7 min"},
+}
+
+print(f"{'Method':<16} {'PSNR':>6} {'FPS':>8} {'Training':>10}")
+print("-" * 44)
+for name, m in methods.items():
+    print(f"{name:<16} {m['psnr']:>6.2f} {m['fps']:>8.2f} "
+          f"{m['train_time']:>10}")
+```
+
+## Implementation Resources
+
+```bash
+# Original implementation
+git clone https://github.com/graphdeco-inria/gaussian-splatting
+cd gaussian-splatting
+pip install -r requirements.txt
+
+# Train on custom scene
+python train.py -s path/to/colmap/data
+
+# Real-time viewer
+./SIBR_viewers/bin/SIBR_gaussianViewer_app \
+  -m output/trained_model
+```
+
+## Survey Papers
+
+1. **"A Survey on 3D Gaussian Splatting"** (Chen et al., 2024) — comprehensive taxonomy
+2. **"3DGS: Recent Developments and Applications"** (Wu et al., 2024) — application-focused
+3. **"Gaussian Splatting: A Survey"** (Fei et al., 2024) — technical deep dive
+
+## Use Cases
+
+1. **Novel view synthesis**: Photo-realistic rendering from sparse views
+2. **Real-time visualization**: Interactive 3D scene exploration
+3. **Digital twins**: Rapid scene reconstruction for simulation
+4. **VR/AR content**: Real-time immersive experiences
+5. **Autonomous driving**: Street-level scene understanding
+
+## References
+
+- [awesome-3D-gaussian-splatting](https://github.com/MrNeRF/awesome-3D-gaussian-splatting)
+- [Original 3DGS](https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/)
+- [3DGS Papers Collection](https://3dgaussians.github.io/)

package/skills/domains/cs/llm-aiops-guide/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: llm-aiops-guide
+description: "Papers on LLMs for IT operations and AIOps research"
+metadata:
+  openclaw:
+    emoji: "🖥️"
+    category: "domains"
+    subcategory: "cs"
+    keywords: ["AIOps", "LLM operations", "IT automation", "log analysis", "incident management", "DevOps AI"]
+    source: "https://github.com/Jun-jie-Huang/awesome-LLM-AIOps"
+---
+
+# LLM for AIOps Guide
+
+## Overview
+
+A curated collection of research on applying LLMs to IT Operations (AIOps) — log analysis, anomaly detection, incident management, root cause analysis, and automated remediation. Tracks how foundation models are transforming traditional rule-based operations tooling into intelligent, adaptive systems. Relevant for CS researchers at the intersection of systems, NLP, and operations.
+
+## Research Areas
+
+```
+LLM for AIOps
+├── Log Analysis
+│   ├── Log parsing (template extraction)
+│   ├── Anomaly detection (from log sequences)
+│   ├── Log summarization
+│   └── Root cause from logs
+├── Incident Management
+│   ├── Incident triage and routing
+│   ├── Severity classification
+│   ├── Similar incident retrieval
+│   └── Resolution recommendation
+├── Root Cause Analysis
+│   ├── Topology-aware diagnosis
+│   ├── Multi-signal correlation
+│   └── Causal inference
+├── Monitoring & Alerting
+│   ├── Metric anomaly detection
+│   ├── Alert correlation
+│   ├── Noise reduction
+│   └── Capacity planning
+└── Automated Remediation
+    ├── Runbook generation
+    ├── Script generation
+    ├── Self-healing systems
+    └── Change impact analysis
+```
+
+## Key Papers
+
+| Paper | Year | Focus |
+|-------|------|-------|
+| LogPPT | 2023 | Few-shot log parsing with prompt tuning |
+| OpsEval | 2024 | Benchmark for evaluating LLMs in AIOps |
+| D-Bot | 2024 | LLM-based database diagnosis |
+| RCAgent | 2024 | Agent for root cause analysis |
+| LogAgent | 2024 | Autonomous log analysis agent |
+
+## Use Cases
+
+1. **Literature tracking**: Follow LLM-AIOps research evolution
+2. **System design**: Learn intelligent operations patterns
+3. **Benchmark comparison**: Evaluate AIOps approaches
+4. **Research planning**: Identify under-explored AIOps problems
+5. **Industry applications**: Bridge research to production AIOps
+
+## References
+
+- [awesome-LLM-AIOps](https://github.com/Jun-jie-Huang/awesome-LLM-AIOps)
+- [OpsEval Benchmark](https://arxiv.org/abs/2310.07637)

package/skills/domains/cs/software-heritage-api/SKILL.md

@@ -0,0 +1,200 @@
+---
+name: software-heritage-api
+description: "Archive and retrieve source code history via Software Heritage API"
+metadata:
+  openclaw:
+    emoji: "💾"
+    category: "domains"
+    subcategory: "cs"
+    keywords: ["Software Heritage", "code archive", "source code preservation", "SWHID", "code provenance", "open source"]
+    source: "https://www.softwareheritage.org/"
+---
+
+# Software Heritage API
+
+## Overview
+
+Software Heritage is the universal archive of software source code, preserving 18B+ source files from 280M+ software origins (GitHub, GitLab, Bitbucket, CRAN, PyPI, Debian, etc.). Each artifact receives a persistent SWHID (SoftWare Heritage IDentifier) for reliable citation in research. The API enables code search, provenance tracking, and historical analysis. Free, no authentication for read access.
+
+## API Endpoints
+
+### Base URL
+
+```
+https://archive.softwareheritage.org/api/1
+```
+
+### Search Origins (Repositories)
+
+```bash
+# Search for repositories
+curl "https://archive.softwareheritage.org/api/1/origin/search/scikit-learn/?limit=10"
+
+# Get origin metadata
+curl "https://archive.softwareheritage.org/api/1/origin/https://github.com/scikit-learn/scikit-learn/get/"
+
+# List visits (snapshots) of an origin
+curl "https://archive.softwareheritage.org/api/1/origin/https://github.com/scikit-learn/scikit-learn/visits/"
+```
+
+### Retrieve Content
+
+```bash
+# Get a specific file by its SHA1 hash
+curl "https://archive.softwareheritage.org/api/1/content/sha1:adc83b19e793491b1c6ea0fd8b46cd9f32e592fc/"
+
+# Get raw file content
+curl "https://archive.softwareheritage.org/api/1/content/sha1:adc83b19e793491b1c6ea0fd8b46cd9f32e592fc/raw/"
+
+# Get directory listing
+curl "https://archive.softwareheritage.org/api/1/directory/{sha1_git}/"
+```
+
+### Resolve SWHIDs
+
+```bash
+# Resolve a SWHID to its object
+curl "https://archive.softwareheritage.org/api/1/resolve/swh:1:cnt:adc83b19e793491b1c6ea0fd8b46cd9f32e592fc/"
+
+# Get snapshot
+curl "https://archive.softwareheritage.org/api/1/snapshot/{sha1_git}/"
+
+# Get revision (commit)
+curl "https://archive.softwareheritage.org/api/1/revision/{sha1_git}/"
+```
+
+### Save Code Now
+
+```bash
+# Request archival of a repository
+curl -X POST "https://archive.softwareheritage.org/api/1/origin/save/git/url/https://github.com/user/repo/"
+```
+
+## SWHID Format
+
+SoftWare Heritage persistent IDentifiers:
+
+```
+swh:1:{type}:{hash}
+
+Types:
+  cnt  → Content (file)
+  dir  → Directory
+  rev  → Revision (commit)
+  rel  → Release (tag)
+  snp  → Snapshot
+
+Examples:
+  swh:1:cnt:94a9ed024d3859793618152ea559a168bbcbb5e2  (file)
+  swh:1:rev:309cf2674ee7a0749978cf8265ab91a60aea0f7d  (commit)
+  swh:1:snp:c7c108084bc0bf3d81436bf980b46e98571c7b17  (snapshot)
+
+With qualifiers:
+  swh:1:cnt:{hash};origin=https://github.com/user/repo;visit=swh:1:snp:{hash};path=/src/main.py
+```
+
+## Python Usage
+
+```python
+import requests
+import time
+
+BASE_URL = "https://archive.softwareheritage.org/api/1"
+
+
+def search_origins(query: str, limit: int = 10) -> list:
+    """Search Software Heritage for archived repositories."""
+    resp = requests.get(
+        f"{BASE_URL}/origin/search/{query}/",
+        params={"limit": limit},
+        timeout=30,
+    )
+    resp.raise_for_status()
+    return [
+        {
+            "url": o.get("url"),
+            "has_visits": o.get("has_visits"),
+        }
+        for o in resp.json()
+    ]
+
+
+def get_origin_visits(origin_url: str) -> list:
+    """Get archival snapshots for a repository."""
+    resp = requests.get(
+        f"{BASE_URL}/origin/{origin_url}/visits/",
+        timeout=30,
+    )
+    resp.raise_for_status()
+    return [
+        {
+            "date": v.get("date"),
+            "status": v.get("status"),
+            "snapshot": v.get("snapshot"),
+            "type": v.get("type"),
+        }
+        for v in resp.json()
+    ]
+
+
+def get_directory(sha1_git: str) -> list:
+    """List files in an archived directory."""
+    resp = requests.get(
+        f"{BASE_URL}/directory/{sha1_git}/",
+        timeout=30,
+    )
+    resp.raise_for_status()
+    return [
+        {
+            "name": entry.get("name"),
+            "type": entry.get("type"),
+            "target": entry.get("target"),
+        }
+        for entry in resp.json()
+    ]
+
+
+def save_code_now(repo_url: str) -> dict:
+    """Request Software Heritage to archive a repository."""
+    resp = requests.post(
+        f"{BASE_URL}/origin/save/git/url/{repo_url}/",
+        timeout=30,
+    )
+    resp.raise_for_status()
+    return resp.json()
+
+
+# Example: find archived ML frameworks
+origins = search_origins("pytorch", limit=5)
+for o in origins:
+    print(f"Archived: {o['url']}")
+
+# Example: get snapshot history
+visits = get_origin_visits("https://github.com/pytorch/pytorch")
+for v in visits[:5]:
+    print(f"[{v['date'][:10]}] {v['status']} — {v['type']}")
+
+# Example: request archival
+# result = save_code_now("https://github.com/my-org/my-research-code")
+# print(f"Save request: {result['save_request_status']}")
+```
+
+## Use Cases
+
+1. **Code citation**: Cite specific code versions in papers using SWHIDs
+2. **Reproducibility**: Archive the exact code used in experiments
+3. **Provenance tracking**: Trace code evolution and authorship
+4. **Software archaeology**: Study historical codebases
+5. **Compliance**: Ensure open-source license compliance through archival
+
+## Rate Limits
+
+- Unauthenticated: 120 requests/hour
+- Authenticated (free token): 1200 requests/hour
+
+## References
+
+- [Software Heritage](https://www.softwareheritage.org/)
+- [API Documentation](https://archive.softwareheritage.org/api/)
+- [SWHID Specification](https://docs.softwareheritage.org/devel/swh-model/persistent-identifiers.html)
+- Di Cosmo, R. & Zacchiroli, S. (2017). "Software Heritage: Why and How to Preserve Software Source Code." *iPRES 2017*.