@wentorai/research-plugins 1.1.0 → 1.2.0

package/skills/analysis/wrangling/claude-data-analysis-guide/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: claude-data-analysis-guide
+description: "Claude Code-based conversational data analysis agent"
+metadata:
+  openclaw:
+    emoji: "🔬"
+    category: "analysis"
+    subcategory: "wrangling"
+    keywords: ["Claude Code", "data analysis", "conversational", "pandas", "visualization", "interactive"]
+    source: "https://github.com/liangdabiao/claude-data-analysis"
+---
+
+# Claude Data Analysis Guide
+
+## Overview
+
+A Claude Code-based data analysis agent that provides conversational data exploration and analysis. Upload datasets and ask questions in natural language — the agent writes and executes Python code for data cleaning, statistical analysis, visualization, and reporting. Leverages Claude Code's ability to read files, run code, and iterate on results.
+
+## Setup
+
+```markdown
+### CLAUDE.md Configuration
+# Data Analysis Project
+
+## Instructions
+- Analyze data files in the data/ directory
+- Use pandas, numpy, scipy, matplotlib, seaborn
+- Always show data shape and dtypes first
+- Include statistical tests where appropriate
+- Generate publication-quality figures (300 DPI)
+- Save outputs to output/ directory
+
+## Conventions
+- Use seaborn for statistical plots
+- Report confidence intervals, not just p-values
+- Handle missing data explicitly (report, then impute)
+- Set random_state=42 for reproducibility
+```
+
+## Workflow
+
+```markdown
+### Interactive Analysis Loop
+1. "Load the experiment data from data/results.csv"
+   → Agent reads file, shows shape, dtypes, head()
+
+2. "How many missing values are there?"
+   → Agent runs df.isnull().sum(), reports per column
+
+3. "Show the distribution of response time by condition"
+   → Agent creates violin plots, reports summary stats
+
+4. "Is there a significant difference between groups?"
+   → Agent runs appropriate test (t-test, ANOVA, etc.)
+
+5. "Build a regression model predicting response time"
+   → Agent fits model, reports coefficients, R², diagnostics
+
+6. "Create a summary report with all findings"
+   → Agent generates markdown report with embedded figures
+```
+
+## Common Analysis Patterns
+
+```python
+# Data profiling
+import pandas as pd
+df = pd.read_csv("data/experiment.csv")
+print(f"Shape: {df.shape}")
+print(f"\nDtypes:\n{df.dtypes}")
+print(f"\nMissing:\n{df.isnull().sum()}")
+print(f"\nDescribe:\n{df.describe()}")
+
+# Statistical comparison
+from scipy import stats
+group_a = df[df["condition"] == "A"]["score"]
+group_b = df[df["condition"] == "B"]["score"]
+t_stat, p_value = stats.ttest_ind(group_a, group_b)
+print(f"t={t_stat:.3f}, p={p_value:.4f}")
+
+# Visualization
+import seaborn as sns
+import matplotlib.pyplot as plt
+fig, ax = plt.subplots(figsize=(8, 5))
+sns.violinplot(data=df, x="condition", y="score", ax=ax)
+plt.savefig("output/comparison.png", dpi=300, bbox_inches="tight")
+```
+
+## Use Cases
+
+1. **Experiment analysis**: Interactive analysis of lab data
+2. **EDA**: Rapid exploration of unfamiliar datasets
+3. **Statistical testing**: Guided hypothesis testing
+4. **Report generation**: Analysis reports with figures
+5. **Learning**: Interactive data science exploration
+
+## References
+
+- [claude-data-analysis GitHub](https://github.com/liangdabiao/claude-data-analysis)
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code)

package/skills/analysis/wrangling/open-data-scientist-guide/SKILL.md

@@ -0,0 +1,197 @@
+---
+name: open-data-scientist-guide
+description: "AI agent that performs end-to-end data science workflows"
+metadata:
+  openclaw:
+    emoji: "📊"
+    category: "analysis"
+    subcategory: "wrangling"
+    keywords: ["data science", "automated analysis", "EDA", "feature engineering", "data wrangling", "AI agent"]
+    source: "https://github.com/Open-Data-Scientist/open-data-scientist"
+---
+
+# Open Data Scientist Guide
+
+## Overview
+
+Open Data Scientist is an AI agent that automates end-to-end data science workflows — from data loading and cleaning through exploratory analysis, feature engineering, modeling, and report generation. It interprets natural language task descriptions, generates and executes Python code, iteratively refines analyses based on results, and produces publication-ready outputs. Designed for researchers who need quick, thorough data analyses without deep programming expertise.
+
+## Workflow Pipeline
+
+```
+Dataset + Task Description
+         ↓
+   Data Profiling (types, distributions, missing values)
+         ↓
+   Cleaning & Preprocessing (imputation, encoding, scaling)
+         ↓
+   Exploratory Data Analysis (correlations, distributions, outliers)
+         ↓
+   Feature Engineering (transforms, interactions, selection)
+         ↓
+   Modeling (train, evaluate, compare)
+         ↓
+   Report Generation (figures, tables, interpretation)
+```
+
+## Usage
+
+```python
+from open_data_scientist import DataScientist
+
+ds = DataScientist(llm_provider="anthropic")
+
+# Natural language task
+result = ds.analyze(
+    data="experiment_results.csv",
+    task="Identify which experimental conditions significantly affect "
+         "the response variable. Build a predictive model and report "
+         "the most important features.",
+)
+
+# Outputs
+print(result.summary)           # Text summary of findings
+result.save_report("report.html")  # Full HTML report
+result.save_figures("figures/")     # All generated plots
+```
+
+## Data Profiling
+
+```python
+# Automatic data profiling before analysis
+profile = ds.profile("dataset.csv")
+
+print(f"Rows: {profile.n_rows}, Columns: {profile.n_cols}")
+print(f"Missing values: {profile.missing_summary}")
+print(f"Data types: {profile.dtype_summary}")
+print(f"Potential issues: {profile.warnings}")
+
+# Column-level details
+for col in profile.columns:
+    print(f"\n{col.name} ({col.dtype}):")
+    print(f"  Unique: {col.n_unique}")
+    print(f"  Missing: {col.n_missing} ({col.pct_missing:.1f}%)")
+    if col.is_numeric:
+        print(f"  Range: [{col.min}, {col.max}]")
+        print(f"  Mean: {col.mean:.3f}, Std: {col.std:.3f}")
+```
+
+## Exploratory Data Analysis
+
+```python
+# Guided EDA
+eda_result = ds.explore(
+    data="dataset.csv",
+    focus="relationships",  # or "distributions", "outliers", "time_trends"
+    target_column="outcome",
+)
+
+# Generated analyses include:
+# - Correlation heatmap
+# - Pairwise scatter plots for top correlations
+# - Distribution plots per group
+# - Statistical tests (t-test, ANOVA, chi-square)
+# - Outlier detection (IQR, Z-score)
+
+for finding in eda_result.findings:
+    print(f"- {finding.description} (p={finding.p_value:.4f})")
+```
+
+## Feature Engineering
+
+```python
+# Automatic feature engineering
+features = ds.engineer_features(
+    data="dataset.csv",
+    target="outcome",
+    strategies=[
+        "polynomial_interactions",  # x1*x2, x1^2
+        "datetime_extraction",      # year, month, day_of_week
+        "text_embeddings",          # TF-IDF or sentence embeddings
+        "binning",                  # numeric to categorical
+        "target_encoding",          # category to target mean
+    ],
+    selection_method="mutual_information",
+    max_features=50,
+)
+
+print(f"Original features: {features.n_original}")
+print(f"Generated features: {features.n_generated}")
+print(f"Selected features: {features.n_selected}")
+```
+
+## Modeling Pipeline
+
+```python
+result = ds.model(
+    data="dataset.csv",
+    target="outcome",
+    task_type="classification",  # or "regression"
+    models=["logistic_regression", "random_forest",
+            "gradient_boosting", "neural_network"],
+    cv_folds=5,
+    metric="f1_macro",
+)
+
+# Model comparison table
+print(result.comparison_table)
+# | Model              | F1 Macro | Accuracy | AUC   |
+# |--------------------|----------|----------|-------|
+# | Gradient Boosting  | 0.847    | 0.862    | 0.921 |
+# | Random Forest      | 0.831    | 0.849    | 0.908 |
+# | ...                |          |          |       |
+
+# Best model details
+best = result.best_model
+print(f"Best: {best.name}")
+print(f"Feature importance:\n{best.feature_importance.head(10)}")
+```
+
+## Report Generation
+
+```python
+# Generate publication-ready report
+result = ds.analyze(
+    data="experiment_results.csv",
+    task="Full analysis with statistical tests",
+    report_config={
+        "format": "html",       # html, pdf, markdown
+        "style": "academic",    # academic, business, minimal
+        "include_code": True,   # Show generated code
+        "figure_dpi": 300,      # Publication quality
+    },
+)
+
+result.save_report("analysis_report.html")
+```
+
+## Configuration
+
+```python
+ds = DataScientist(
+    llm_provider="anthropic",
+    model="claude-sonnet-4-20250514",
+    execution_config={
+        "timeout": 300,             # Max seconds per code block
+        "max_iterations": 10,       # Refinement iterations
+        "sandbox": True,            # Isolated execution
+    },
+    analysis_config={
+        "significance_level": 0.05,
+        "random_state": 42,
+        "test_size": 0.2,
+    },
+)
+```
+
+## Use Cases
+
+1. **Experiment analysis**: Analyze lab or survey data with statistical tests
+2. **Dataset exploration**: Quick EDA on unfamiliar datasets
+3. **Baseline modeling**: Rapid prototyping of predictive models
+4. **Report generation**: Automated analysis reports for publications
+
+## References
+
+- [Open Data Scientist GitHub](https://github.com/Open-Data-Scientist/open-data-scientist)
+- [Pandas Profiling](https://github.com/ydataai/ydata-profiling)

package/skills/analysis/wrangling/streamline-analyst-guide/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: streamline-analyst-guide
+description: "End-to-end data analysis AI agent with Streamlit UI"
+metadata:
+  openclaw:
+    emoji: "📈"
+    category: "analysis"
+    subcategory: "wrangling"
+    keywords: ["data analysis", "Streamlit", "automated EDA", "machine learning", "data science", "AI analyst"]
+    source: "https://github.com/Wilson-ZheLin/Streamline-Analyst"
+---
+
+# Streamline Analyst Guide
+
+## Overview
+
+Streamline Analyst is an end-to-end data analysis AI agent with a Streamlit web interface. Upload a dataset and describe your analysis goal in natural language — the agent handles data cleaning, EDA, feature engineering, model training, evaluation, and report generation. Provides an interactive UI for reviewing each step and adjusting parameters.
+
+## Installation
+
+```bash
+git clone https://github.com/Wilson-ZheLin/Streamline-Analyst.git
+cd Streamline-Analyst
+pip install -r requirements.txt
+streamlit run app.py
+```
+
+## Workflow
+
+```
+Upload Dataset (CSV, Excel, Parquet)
+         ↓
+   Data Profiling
+   ├── Column types and distributions
+   ├── Missing value analysis
+   ├── Correlation matrix
+   └── Outlier detection
+         ↓
+   Data Cleaning (interactive)
+   ├── Handle missing values
+   ├── Remove/fix outliers
+   ├── Type conversions
+   └── Feature encoding
+         ↓
+   EDA (automated + custom)
+   ├── Univariate analysis
+   ├── Bivariate relationships
+   ├── Statistical tests
+   └── Custom visualizations
+         ↓
+   Modeling (if applicable)
+   ├── Train/test split
+   ├── Model selection + training
+   ├── Hyperparameter tuning
+   └── Evaluation metrics
+         ↓
+   Report Generation
+```
+
+## Features
+
+```python
+# Streamline Analyst provides:
+
+# 1. Smart data profiling
+# - Auto-detect column types (numeric, categorical, datetime)
+# - Distribution analysis per column
+# - Missing value patterns (MCAR, MAR, MNAR hints)
+# - Correlation analysis with significance
+
+# 2. Interactive cleaning
+# - Imputation strategies (mean, median, mode, KNN, model)
+# - Outlier handling (IQR, Z-score, isolation forest)
+# - Encoding (one-hot, label, target, ordinal)
+# - Scaling (standard, minmax, robust)
+
+# 3. Automated EDA
+# - Distribution plots (histogram, KDE, box, violin)
+# - Relationship plots (scatter, pair, heatmap)
+# - Time series decomposition
+# - Statistical tests (t-test, ANOVA, chi-square, Mann-Whitney)
+
+# 4. Model pipeline
+# - Classification: LR, RF, GBM, SVM, MLP
+# - Regression: LR, RF, GBM, SVR, ElasticNet
+# - Cross-validation with confidence intervals
+# - Feature importance visualization
+# - SHAP explanations
+
+# 5. Report
+# - HTML report with all plots and findings
+# - Downloadable cleaned dataset
+# - Model artifacts (pickle)
+```
+
+## Natural Language Interface
+
+```markdown
+### Example Prompts
+- "Show me the distribution of all numeric columns"
+- "Is there a significant difference in income between genders?"
+- "Build a classifier to predict churn using all features"
+- "What are the top 5 most important features for prediction?"
+- "Clean the data: fill missing values and remove outliers"
+- "Generate a summary report of this dataset"
+```
+
+## Use Cases
+
+1. **Quick EDA**: Rapid exploration of unfamiliar datasets
+2. **Data cleaning**: Interactive preprocessing with AI guidance
+3. **Baseline models**: Quick ML prototyping without coding
+4. **Report generation**: Automated analysis reports
+5. **Teaching**: Interactive data science demonstrations
+
+## References
+
+- [Streamline-Analyst GitHub](https://github.com/Wilson-ZheLin/Streamline-Analyst)
+- [Streamlit](https://streamlit.io/)

package/skills/domains/ai-ml/ai-agent-papers-guide/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: ai-agent-papers-guide
+description: "Curated 2024-2026 AI agent research papers collection"
+metadata:
+  openclaw:
+    emoji: "📑"
+    category: "domains"
+    subcategory: "ai-ml"
+    keywords: ["AI agents", "agent papers", "2024 research", "LLM agents", "agent frameworks", "survey"]
+    source: "https://github.com/VoltAgent/awesome-ai-agent-papers"
+---
+
+# AI Agent Papers Guide (2024-2026)
+
+## Overview
+
+A focused collection of AI agent research papers from 2024-2026, tracking the latest developments in LLM-based agent systems. Unlike broader collections, this focuses on recent breakthroughs — new architectures, benchmarks, multi-agent coordination, and real-world applications. Updated frequently as the field evolves rapidly.
+
+## Paper Categories
+
+```
+Recent AI Agent Research
+├── Agent Architectures
+│   ├── Planning (o1-style reasoning, search-augmented)
+│   ├── Memory (long-term, episodic, working)
+│   └── Tool use (function calling, code execution)
+├── Multi-Agent Systems
+│   ├── Collaboration (task decomposition, debate)
+│   ├── Competition (red team, adversarial)
+│   └── Emergence (self-organization, culture)
+├── Evaluation
+│   ├── Benchmarks (SWE-bench, WebArena, GAIA)
+│   ├── Safety (jailbreak, misuse, alignment)
+│   └── Reliability (error recovery, hallucination)
+├── Applications
+│   ├── Software engineering (coding agents)
+│   ├── Scientific research (lab automation)
+│   ├── Web automation (browsing, form-filling)
+│   └── Enterprise (workflow, data analysis)
+└── Infrastructure
+    ├── Frameworks (LangGraph, CrewAI, AutoGen)
+    ├── Protocols (MCP, A2A, tool standards)
+    └── Deployment (scaling, monitoring, cost)
+```
+
+## Highlighted Papers (2024-2025)
+
+| Paper | Venue | Key Contribution |
+|-------|-------|-----------------|
+| SWE-agent | ICLR 2025 | Agent interface design for SE |
+| OpenHands | 2024 | Open platform for coding agents |
+| AgentBench | ICLR 2024 | Multi-environment agent benchmark |
+| GAIA | ICLR 2024 | General AI assistant benchmark |
+| Voyager | NeurIPS 2024 | Lifelong learning in Minecraft |
+| OS-Copilot | 2024 | Self-improving computer agent |
+| AutoGen | 2024 | Multi-agent conversation framework |
+| Agent-FLAN | ACL 2024 | Agent fine-tuning methodology |
+
+## Tracking New Papers
+
+```python
+import arxiv
+from datetime import datetime, timedelta
+
+def find_recent_agent_papers(days=14):
+    """Find cutting-edge agent papers."""
+    queries = [
+        "ti:agent AND (ti:LLM OR ti:language model)",
+        "abs:autonomous agent AND abs:tool use AND abs:2024",
+        "ti:multi-agent AND abs:large language",
+        "abs:coding agent OR abs:software agent",
+    ]
+
+    seen = set()
+    papers = []
+
+    for q in queries:
+        search = arxiv.Search(
+            query=q, max_results=15,
+            sort_by=arxiv.SortCriterion.SubmittedDate,
+        )
+        for r in search.results():
+            if r.entry_id not in seen:
+                seen.add(r.entry_id)
+                papers.append({
+                    "title": r.title,
+                    "date": r.published.strftime("%Y-%m-%d"),
+                    "url": r.entry_id,
+                })
+
+    papers.sort(key=lambda x: x["date"], reverse=True)
+    for p in papers[:20]:
+        print(f"[{p['date']}] {p['title']}")
+        print(f"  {p['url']}")
+
+find_recent_agent_papers()
+```
+
+## Framework Comparison
+
+```python
+frameworks = {
+    "LangGraph": {
+        "paradigm": "Graph-based workflows",
+        "persistence": "Built-in checkpointing",
+        "multi_agent": "Yes",
+        "language": "Python/JS",
+    },
+    "CrewAI": {
+        "paradigm": "Role-based agents",
+        "persistence": "Memory module",
+        "multi_agent": "Yes (crew)",
+        "language": "Python",
+    },
+    "AutoGen": {
+        "paradigm": "Conversational agents",
+        "persistence": "Chat history",
+        "multi_agent": "Yes (group chat)",
+        "language": "Python/.NET",
+    },
+    "OpenHands": {
+        "paradigm": "Computer use agent",
+        "persistence": "Workspace state",
+        "multi_agent": "No",
+        "language": "Python",
+    },
+}
+
+for name, info in frameworks.items():
+    print(f"\n{name}:")
+    for k, v in info.items():
+        print(f"  {k}: {v}")
+```
+
+## Use Cases
+
+1. **Literature tracking**: Stay current on agent research
+2. **Framework selection**: Compare agent development tools
+3. **Research planning**: Identify open problems and trends
+4. **Course material**: Teach cutting-edge agent systems
+5. **Benchmark tracking**: Compare agent capabilities
+
+## References
+
+- [awesome-ai-agent-papers](https://github.com/VoltAgent/awesome-ai-agent-papers)
+- [VoltAgent Framework](https://github.com/VoltAgent/voltagent)