@wentorai/research-plugins 1.0.0

package/skills/domains/economics/fred-api/SKILL.md

@@ -0,0 +1,189 @@
+---
+name: fred-api
+description: "Federal Reserve Economic Data API for US economic indicators"
+metadata:
+  openclaw:
+    emoji: "🔍"
+    category: "domains"
+    subcategory: "economics"
+    keywords: ["microeconomics", "macroeconomics", "econometrics", "development economics"]
+    source: "https://fred.stlouisfed.org/docs/api/fred/"
+    requires:
+      env: ["FRED_API_KEY"]
+---
+
+# FRED API Guide
+
+## Overview
+
+FRED (Federal Reserve Economic Data) is a database maintained by the Research Division of the Federal Reserve Bank of St. Louis. It contains over 800,000 economic time series from dozens of national and international sources, covering macroeconomic indicators, financial markets, employment, trade, monetary policy, and more.
+
+The FRED API provides programmatic access to this extensive economic data repository. Researchers can retrieve time series observations, search for data series by keyword or category, explore release schedules, and access vintage (real-time) data for historical analysis. The data spans decades and in some cases centuries, making it invaluable for longitudinal economic research.
+
+Economists, financial analysts, policy researchers, data scientists, and academic institutions rely on the FRED API for econometric modeling, macroeconomic forecasting, policy analysis, and teaching. It is one of the most widely used economic data APIs in academic research and is cited in thousands of peer-reviewed publications.
+
+## Authentication
+
+Authentication requires a free API key from the Federal Reserve Bank of St. Louis.
+
+1. Register for an account at https://fredaccount.stlouisfed.org/login/secure/
+2. Request an API key at https://fredaccount.stlouisfed.org/apikeys
+3. Include the key as the `api_key` query parameter in all requests
+
+```bash
+curl "https://api.stlouisfed.org/fred/series?series_id=GDP&api_key=YOUR_KEY&file_type=json"
+```
+
+API keys are free and available to anyone who registers. There is no fee or approval process.
+
+## Core Endpoints
+
+### series: Retrieve Series Metadata
+
+Get metadata about a specific economic data series, including title, frequency, units, seasonal adjustment, and date range.
+
+- **URL**: `GET https://api.stlouisfed.org/fred/series`
+- **Parameters**:
+
+| Parameter  | Type   | Required | Description                                |
+|------------|--------|----------|--------------------------------------------|
+| series_id  | string | Yes      | FRED series identifier (e.g., `GDP`)       |
+| api_key    | string | Yes      | Your FRED API key                          |
+| file_type  | string | No       | Response format: `json` or `xml` (default) |
+
+- **Example**:
+
+```bash
+curl "https://api.stlouisfed.org/fred/series?series_id=UNRATE&api_key=YOUR_KEY&file_type=json"
+```
+
+- **Response**: Returns `seriess` array with `id`, `title`, `observation_start`, `observation_end`, `frequency`, `units`, `seasonal_adjustment`, `notes`, and `popularity` ranking.
+
+### observations: Retrieve Time Series Data
+
+Fetch actual data points (observations) for a specific economic series over a date range.
+
+- **URL**: `GET https://api.stlouisfed.org/fred/series/observations`
+- **Parameters**:
+
+| Parameter          | Type   | Required | Description                                        |
+|--------------------|--------|----------|----------------------------------------------------|
+| series_id          | string | Yes      | FRED series identifier                             |
+| api_key            | string | Yes      | Your FRED API key                                  |
+| observation_start  | string | No       | Start date in YYYY-MM-DD format                    |
+| observation_end    | string | No       | End date in YYYY-MM-DD format                      |
+| frequency          | string | No       | Aggregation: `d`, `w`, `m`, `q`, `a`              |
+| aggregation_method | string | No       | `avg`, `sum`, `eop` (end of period)                |
+| file_type          | string | No       | `json` or `xml`                                    |
+
+- **Example**:
+
+```bash
+curl "https://api.stlouisfed.org/fred/series/observations?series_id=GDP&observation_start=2020-01-01&api_key=YOUR_KEY&file_type=json"
+```
+
+- **Response**: Returns `observations` array with `date` and `value` for each observation period.
+
+### category: Browse Data Categories
+
+Navigate the hierarchical FRED category system to discover available data series organized by topic.
+
+- **URL**: `GET https://api.stlouisfed.org/fred/category`
+- **Parameters**:
+
+| Parameter   | Type   | Required | Description                                   |
+|-------------|--------|----------|-----------------------------------------------|
+| category_id | int    | Yes      | Category ID (0 for root)                      |
+| api_key     | string | Yes      | Your FRED API key                             |
+| file_type   | string | No       | `json` or `xml`                               |
+
+- **Example**:
+
+```bash
+curl "https://api.stlouisfed.org/fred/category/children?category_id=0&api_key=YOUR_KEY&file_type=json"
+```
+
+- **Response**: Returns `categories` array with `id`, `name`, and `parent_id` for child categories.
+
+### releases: Track Data Release Schedules
+
+Retrieve information about data releases, which group related series that are published together.
+
+- **URL**: `GET https://api.stlouisfed.org/fred/releases`
+- **Parameters**:
+
+| Parameter  | Type   | Required | Description                           |
+|------------|--------|----------|---------------------------------------|
+| api_key    | string | Yes      | Your FRED API key                     |
+| file_type  | string | No       | `json` or `xml`                       |
+
+- **Example**:
+
+```bash
+curl "https://api.stlouisfed.org/fred/releases?api_key=YOUR_KEY&file_type=json"
+```
+
+- **Response**: Returns `releases` array with `id`, `name`, `press_release`, `link`, and release notes.
+
+## Rate Limits
+
+The FRED API enforces rate limits that vary by usage. Standard limits allow approximately 120 requests per minute. Exceeding the limit returns HTTP 429 responses. For bulk data retrieval, consider using the FRED Excel add-in or downloading bulk files from https://fred.stlouisfed.org/. Academic users can contact FRED for elevated limits if needed.
+
+## Common Patterns
+
+### Retrieve and Plot GDP Data
+
+Fetch quarterly GDP observations for macroeconomic analysis:
+
+```python
+import requests
+
+params = {
+    "series_id": "GDP",
+    "api_key": "YOUR_KEY",
+    "file_type": "json",
+    "observation_start": "2015-01-01"
+}
+resp = requests.get("https://api.stlouisfed.org/fred/series/observations", params=params)
+data = resp.json()
+
+for obs in data["observations"]:
+    print(f"{obs['date']}: ${obs['value']}B")
+```
+
+### Compare Multiple Economic Indicators
+
+Build a multi-series dataset for econometric analysis:
+
+```python
+import requests
+
+series_ids = ["UNRATE", "CPIAUCSL", "FEDFUNDS", "GDP"]
+api_key = os.environ["FRED_API_KEY"]
+
+for sid in series_ids:
+    resp = requests.get("https://api.stlouisfed.org/fred/series/observations", params={
+        "series_id": sid,
+        "api_key": api_key,
+        "file_type": "json",
+        "observation_start": "2020-01-01",
+        "frequency": "m"
+    })
+    obs = resp.json()["observations"]
+    print(f"{sid}: {len(obs)} monthly observations retrieved")
+```
+
+### Search for Series by Keyword
+
+Discover available data series on a specific topic:
+
+```bash
+curl "https://api.stlouisfed.org/fred/series/search?search_text=consumer+price+index&api_key=YOUR_KEY&file_type=json&limit=10"
+```
+
+## References
+
+- Official API documentation: https://fred.stlouisfed.org/docs/api/fred/
+- FRED homepage: https://fred.stlouisfed.org/
+- Series search: https://fred.stlouisfed.org/docs/api/fred/series_search.html
+- Category tree: https://fred.stlouisfed.org/docs/api/fred/category.html

package/skills/domains/education/curriculum-design-guide/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: curriculum-design-guide
+description: "Systematic approaches to curriculum design using backward design and alignment"
+metadata:
+  openclaw:
+    emoji: "books"
+    category: "domains"
+    subcategory: "education"
+    keywords: ["curriculum design", "pedagogy", "education", "study methods", "backward design"]
+    source: "wentor"
+---
+
+# Curriculum Design Guide
+
+A structured skill for designing research-informed curricula using backward design, constructive alignment, and competency-based frameworks. Applicable to higher education course design, training program development, and educational research.
+
+## Backward Design Framework
+
+Understanding by Design (Wiggins & McTighe, 2005) reverses the traditional content-first approach:
+
+### Stage 1: Identify Desired Results
+
+Define what students should know, understand, and be able to do:
+
+```yaml
+course: "Introduction to Research Methods"
+big_ideas:
+  - "Research is a systematic process of inquiry"
+  - "Methodology must align with research questions"
+
+essential_questions:
+  - "How do we know what we know?"
+  - "What makes evidence credible?"
+  - "When should we use qualitative vs. quantitative methods?"
+
+learning_outcomes:
+  - "Formulate testable research questions (Apply)"
+  - "Select appropriate research designs for given questions (Evaluate)"
+  - "Critically appraise published research methodology (Analyze)"
+  - "Design and defend a research proposal (Create)"
+```
+
+### Stage 2: Determine Acceptable Evidence
+
+Design assessments before planning instruction:
+
+```python
+# Assessment blueprint generator
+def create_assessment_blueprint(outcomes: list[str], bloom_levels: list[str],
+                                 weights: list[float]) -> dict:
+    """
+    Generate an assessment blueprint mapping outcomes to
+    assessment types and weights.
+    """
+    assessment_types = {
+        'Remember': 'quiz',
+        'Understand': 'reflection_paper',
+        'Apply': 'problem_set',
+        'Analyze': 'case_study',
+        'Evaluate': 'peer_review',
+        'Create': 'research_proposal'
+    }
+    blueprint = []
+    for outcome, level, weight in zip(outcomes, bloom_levels, weights):
+        blueprint.append({
+            'outcome': outcome,
+            'bloom_level': level,
+            'assessment_type': assessment_types.get(level, 'portfolio'),
+            'weight_pct': weight * 100
+        })
+    return {'blueprint': blueprint, 'total_weight': sum(weights) * 100}
+
+outcomes = [
+    "Formulate research questions",
+    "Select research designs",
+    "Appraise methodology",
+    "Design research proposal"
+]
+levels = ['Apply', 'Evaluate', 'Analyze', 'Create']
+weights = [0.15, 0.20, 0.25, 0.40]
+print(create_assessment_blueprint(outcomes, levels, weights))
+```
+
+### Stage 3: Plan Learning Experiences
+
+Sequence activities that build toward assessment readiness. Use the WHERETO framework:
+
+- **W** -- Where are we going? Why?
+- **H** -- Hook and hold interest
+- **E** -- Equip with experience, tools, knowledge
+- **R** -- Rethink, reflect, revise
+- **E** -- Evaluate understanding
+- **T** -- Tailor to individual needs
+- **O** -- Organize for maximum engagement
+
+## Constructive Alignment
+
+Biggs' Constructive Alignment (1996) ensures coherence between intended learning outcomes (ILOs), teaching/learning activities (TLAs), and assessment tasks (ATs):
+
+```
+ILO: "Students will analyze case studies using SWOT framework"
+  |
+  +--> TLA: Workshop where students collaboratively analyze
+  |         a real company case in small groups
+  |
+  +--> AT:  Individual case analysis report (1500 words)
+            assessed with rubric mapping to ILO verbs
+```
+
+Misalignment is the most common curriculum design failure. Audit each ILO to verify it has at least one matching TLA and one matching AT.
+
+## Competency-Based Curriculum Mapping
+
+For programs with multiple courses, create a curriculum map:
+
+```
+Competency              | Course 1 | Course 2 | Course 3 | Course 4
+------------------------|----------|----------|----------|--------
+Research question design|    I     |    D     |    M     |    A
+Literature review       |    I     |    D     |    D     |    M
+Data collection         |    -     |    I     |    D     |    M
+Statistical analysis    |    -     |    I     |    D     |    A
+Academic writing        |    I     |    D     |    D     |    A
+
+Legend: I = Introduced, D = Developed, M = Mastered, A = Applied
+```
+
+Ensure every competency reaches at least "Mastered" level by program completion, and identify gaps where competencies are introduced but never developed further.
+
+## Quality Assurance
+
+Validate curriculum designs through:
+
+1. External review by discipline experts and industry advisors
+2. Student feedback surveys (mid-semester and end-of-semester)
+3. Learning analytics -- track completion rates, grade distributions, and DFW rates
+4. Periodic program-level assessment with rubric-scored capstone artifacts
+
+Document all revisions in a curriculum changelog to maintain institutional memory and support accreditation reporting.
+
+## References
+
+- Wiggins, G., & McTighe, J. (2005). *Understanding by Design* (2nd ed.). ASCD.
+- Biggs, J. (1996). Enhancing teaching through constructive alignment. *Higher Education*, 32(3), 347-364.

package/skills/domains/education/learning-science-guide/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: learning-science-guide
+description: "Evidence-based learning science principles for educational research and practice"
+metadata:
+  openclaw:
+    emoji: "brain"
+    category: "domains"
+    subcategory: "education"
+    keywords: ["education", "pedagogy", "learning science", "curriculum design", "study methods", "cognitive load"]
+    source: "wentor"
+---
+
+# Learning Science Guide
+
+A comprehensive skill for applying evidence-based learning science principles to educational research, instructional design, and teaching practice. Grounded in cognitive psychology and educational neuroscience.
+
+## Foundational Learning Theories
+
+### Cognitive Load Theory (Sweller, 1988)
+
+Working memory has limited capacity. Effective instruction manages three types of cognitive load:
+
+| Load Type | Definition | Design Strategy |
+|-----------|-----------|-----------------|
+| Intrinsic | Complexity inherent to the material | Sequence from simple to complex; chunk information |
+| Extraneous | Load from poor instructional design | Eliminate redundancy; use spatial contiguity |
+| Germane | Load from schema construction | Use worked examples; encourage self-explanation |
+
+```python
+# Estimate cognitive load using element interactivity
+def estimate_intrinsic_load(elements: list, interactions: list) -> str:
+    """
+    elements: list of knowledge components
+    interactions: list of (element_i, element_j) tuples that must be
+                  processed simultaneously
+    """
+    interactivity = len(interactions) / max(len(elements), 1)
+    if interactivity < 0.3:
+        return "low intrinsic load - suitable for independent study"
+    elif interactivity < 0.7:
+        return "moderate intrinsic load - scaffold with worked examples"
+    else:
+        return "high intrinsic load - use fading strategy and segmenting"
+
+# Example: teaching statistical regression
+elements = ['variable', 'coefficient', 'intercept', 'residual', 'R-squared']
+interactions = [('coefficient', 'variable'), ('intercept', 'residual'),
+                ('coefficient', 'R-squared'), ('residual', 'R-squared')]
+print(estimate_intrinsic_load(elements, interactions))
+```
+
+### Constructivism and Active Learning
+
+Constructivist approaches emphasize that learners build knowledge through experience. Key active learning strategies with measured effect sizes (Freeman et al., 2014, PNAS):
+
+- **Think-Pair-Share**: d = 0.41
+- **Problem-Based Learning (PBL)**: d = 0.68
+- **Peer Instruction (Mazur)**: d = 0.74
+- **Inquiry-Based Labs**: d = 0.52
+
+## Evidence-Based Study Methods
+
+### Retrieval Practice
+
+Testing is not just assessment -- it is a powerful learning tool (Roediger & Karpicke, 2006). Implement the testing effect:
+
+```
+Study Session Structure:
+  1. Initial encoding (read/watch)          - 15 min
+  2. Free recall (close materials, write)   - 10 min
+  3. Check accuracy and fill gaps           -  5 min
+  4. Spaced retrieval after 1 day           - 10 min
+  5. Spaced retrieval after 7 days          - 10 min
+  6. Spaced retrieval after 30 days         - 10 min
+```
+
+### Spaced Repetition Algorithms
+
+Implement optimal review scheduling:
+
+```python
+def next_review_interval(repetition: int, ease_factor: float = 2.5,
+                          quality: int = 4) -> float:
+    """
+    SM-2 inspired algorithm.
+    repetition: number of successful reviews
+    ease_factor: item difficulty (>= 1.3)
+    quality: response quality 0-5
+    """
+    if quality < 3:
+        return 1  # reset to 1 day
+    if repetition == 0:
+        return 1
+    elif repetition == 1:
+        return 6
+    else:
+        interval = 6 * (ease_factor ** (repetition - 1))
+        # Adjust ease factor
+        new_ef = ease_factor + (0.1 - (5 - quality) * (0.08 + (5 - quality) * 0.02))
+        return round(interval, 1)
+
+# Schedule for a moderately difficult concept
+for rep in range(6):
+    days = next_review_interval(rep)
+    print(f"Review {rep + 1}: after {days} days")
+```
+
+### Interleaving and Desirable Difficulties
+
+Research shows interleaved practice (mixing problem types) outperforms blocked practice for long-term retention (Rohrer & Taylor, 2007):
+
+- Blocked: AAABBBCCC -> short-term gains, long-term forgetting
+- Interleaved: ABCBACACB -> harder during practice, better retention
+
+## Assessment Design
+
+### Bloom's Taxonomy Alignment
+
+Map learning objectives to assessment items across cognitive levels:
+
+```yaml
+remember:
+  verbs: [define, list, recall, identify]
+  assessment: "Multiple choice, matching"
+understand:
+  verbs: [explain, summarize, compare, classify]
+  assessment: "Short answer, concept maps"
+apply:
+  verbs: [solve, demonstrate, use, implement]
+  assessment: "Problem sets, simulations"
+analyze:
+  verbs: [differentiate, organize, attribute, deconstruct]
+  assessment: "Case studies, data interpretation"
+evaluate:
+  verbs: [judge, critique, justify, appraise]
+  assessment: "Peer review, rubric-based essays"
+create:
+  verbs: [design, construct, produce, formulate]
+  assessment: "Research projects, portfolios"
+```
+
+### Item Analysis
+
+After administering assessments, compute item difficulty (p-value) and discrimination index to validate question quality. Target p-values between 0.30 and 0.70 and discrimination indices above 0.30 for optimal measurement.
+
+## References
+
+- Sweller, J. (1988). Cognitive load during problem solving. *Cognitive Science*, 12(2), 257-285.
+- Freeman, S., et al. (2014). Active learning increases student performance in science. *PNAS*, 111(23), 8410-8415.
+- Roediger, H. L., & Karpicke, J. D. (2006). Test-enhanced learning. *Psychological Science*, 17(3), 249-255.

package/skills/domains/finance/financial-data-analysis/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: financial-data-analysis
+description: "Methods for acquiring, cleaning, and analyzing financial datasets for research"
+metadata:
+  openclaw:
+    emoji: "money_with_wings"
+    category: "domains"
+    subcategory: "finance"
+    keywords: ["financial data", "stock analysis", "quantitative finance", "data pipeline", "financial API"]
+    source: "wentor"
+---
+
+# Financial Data Analysis
+
+A practical skill for sourcing, processing, and analyzing financial data in academic research contexts. Covers data acquisition from public APIs, cleaning workflows, and standard analytical techniques used in empirical finance research.
+
+## Data Acquisition
+
+### Public Financial Data Sources
+
+| Source | Data Type | Access | Python Package |
+|--------|-----------|--------|---------------|
+| Yahoo Finance | Prices, fundamentals | Free | `yfinance` |
+| FRED (St. Louis Fed) | Macroeconomic indicators | Free (API key) | `fredapi` |
+| SEC EDGAR | Company filings (10-K, 10-Q) | Free | `sec-edgar-downloader` |
+| WRDS (Wharton) | CRSP, Compustat, IBES | University subscription | `wrds` |
+| Alpha Vantage | Real-time and historical prices | Free tier | `alpha_vantage` |
+
+### Fetching Price Data
+
+```python
+import yfinance as yf
+import pandas as pd
+
+def fetch_stock_data(tickers: list[str], start: str, end: str) -> pd.DataFrame:
+    """
+    Fetch adjusted close prices for a list of tickers.
+
+    Args:
+        tickers: List of ticker symbols (e.g., ['AAPL', 'MSFT'])
+        start: Start date (YYYY-MM-DD)
+        end: End date (YYYY-MM-DD)
+    Returns:
+        DataFrame with adjusted close prices
+    """
+    data = yf.download(tickers, start=start, end=end, auto_adjust=True)
+    prices = data['Close'] if len(tickers) > 1 else data[['Close']]
+    prices.columns = tickers if len(tickers) > 1 else tickers
+    return prices
+
+# Fetch 5 years of data
+prices = fetch_stock_data(['AAPL', 'MSFT', 'GOOGL'], '2020-01-01', '2025-01-01')
+print(prices.head())
+```
+
+### Macroeconomic Data from FRED
+
+```python
+from fredapi import Fred
+
+fred = Fred(api_key=os.environ["FRED_API_KEY"])
+
+# Common series for finance research
+series_ids = {
+    'GDP': 'GDP',
+    'CPI': 'CPIAUCSL',
+    'Fed_Funds_Rate': 'FEDFUNDS',
+    'Unemployment': 'UNRATE',
+    '10Y_Treasury': 'DGS10',
+    'VIX': 'VIXCLS'
+}
+
+macro_data = pd.DataFrame()
+for name, sid in series_ids.items():
+    macro_data[name] = fred.get_series(sid, observation_start='2000-01-01')
+```
+
+## Data Cleaning Pipeline
+
+Financial data requires careful cleaning before analysis:
+
+```python
+def clean_financial_data(df: pd.DataFrame) -> pd.DataFrame:
+    """Standard cleaning pipeline for financial time series."""
+    cleaned = df.copy()
+
+    # 1. Handle missing values
+    missing_pct = cleaned.isnull().sum() / len(cleaned) * 100
+    print(f"Missing data:\n{missing_pct}")
+
+    # 2. Forward-fill for market holidays (max 5 days)
+    cleaned = cleaned.ffill(limit=5)
+
+    # 3. Remove remaining NaN rows
+    cleaned = cleaned.dropna()
+
+    # 4. Detect and flag outliers (>5 sigma daily returns)
+    returns = cleaned.pct_change()
+    z_scores = (returns - returns.mean()) / returns.std()
+    outliers = (z_scores.abs() > 5).any(axis=1)
+    print(f"Outlier days flagged: {outliers.sum()}")
+
+    # 5. Verify data integrity
+    assert cleaned.index.is_monotonic_increasing, "Index must be sorted"
+    assert not cleaned.duplicated().any(), "No duplicate rows allowed"
+
+    return cleaned
+```
+
+## Standard Financial Metrics
+
+### Return Calculations
+
+```python
+def compute_returns(prices: pd.DataFrame) -> dict:
+    """Compute standard return metrics."""
+    simple_returns = prices.pct_change().dropna()
+    log_returns = np.log(prices / prices.shift(1)).dropna()
+
+    annualized_return = simple_returns.mean() * 252
+    annualized_vol = simple_returns.std() * np.sqrt(252)
+    sharpe_ratio = annualized_return / annualized_vol
+
+    # Maximum drawdown
+    cumulative = (1 + simple_returns).cumprod()
+    rolling_max = cumulative.cummax()
+    drawdown = (cumulative - rolling_max) / rolling_max
+    max_drawdown = drawdown.min()
+
+    return {
+        'annualized_return': annualized_return,
+        'annualized_volatility': annualized_vol,
+        'sharpe_ratio': sharpe_ratio,
+        'max_drawdown': max_drawdown
+    }
+```
+
+## Event Studies
+
+A common methodology in empirical finance research:
+
+1. Define the event window (e.g., [-5, +5] trading days around earnings announcement)
+2. Estimate normal returns using the market model over the estimation window (e.g., [-250, -30])
+3. Compute abnormal returns: AR = R_actual - R_expected
+4. Aggregate cumulative abnormal returns (CAR) across firms
+5. Test statistical significance using parametric (Patell test) and non-parametric (sign test) methods
+
+Always report both raw and risk-adjusted results, and perform robustness checks with different estimation windows and benchmark models.
+
+## Reproducibility
+
+Store all data processing steps in version-controlled scripts. Use `pandas.DataFrame.to_parquet()` for efficient storage of intermediate datasets, and document data provenance including download dates, API versions, and any filters applied.