@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/domains/ecology/species-distribution-guide/SKILL.md

@@ -0,0 +1,343 @@
+---
+name: species-distribution-guide
+description: "Species distribution modeling with MaxEnt, SDM methods, and GBIF data"
+metadata:
+  openclaw:
+    emoji: "paw-prints"
+    category: "domains"
+    subcategory: "ecology"
+    keywords: ["species-distribution", "maxent", "sdm", "gbif", "ecological-niche", "biodiversity", "habitat"]
+    source: "wentor"
+---
+
+# Species Distribution Modeling Guide
+
+A skill for building and evaluating species distribution models (SDMs), covering occurrence data acquisition from biodiversity databases, environmental predictor preparation, model fitting with MaxEnt and ensemble methods, model evaluation, and projection under climate change scenarios.
+
+## Occurrence Data
+
+### Accessing GBIF Data
+
+The Global Biodiversity Information Facility (GBIF) is the primary source of species occurrence records:
+
+```python
+from pygbif import occurrences, species
+
+def download_occurrences(species_name: str, country: str = None,
+                          limit: int = 5000,
+                          has_coordinate: bool = True) -> dict:
+    """
+    Download species occurrence records from GBIF.
+    species_name: scientific name (e.g., 'Panthera tigris')
+    Returns cleaned occurrence records with coordinates.
+    """
+    # Get GBIF species key
+    name_result = species.name_backbone(name=species_name)
+    if "usageKey" not in name_result:
+        return {"error": f"Species not found: {species_name}"}
+
+    species_key = name_result["usageKey"]
+
+    # Search occurrences
+    params = {
+        "taxonKey": species_key,
+        "hasCoordinate": has_coordinate,
+        "hasGeospatialIssue": False,
+        "limit": limit,
+    }
+    if country:
+        params["country"] = country
+
+    results = occurrences.search(**params)
+
+    # Clean records
+    records = []
+    seen_coords = set()
+    for rec in results.get("results", []):
+        lat = rec.get("decimalLatitude")
+        lon = rec.get("decimalLongitude")
+        if lat is None or lon is None:
+            continue
+
+        # Remove exact duplicates
+        coord_key = (round(lat, 4), round(lon, 4))
+        if coord_key in seen_coords:
+            continue
+        seen_coords.add(coord_key)
+
+        records.append({
+            "species": rec.get("species", species_name),
+            "latitude": lat,
+            "longitude": lon,
+            "year": rec.get("year"),
+            "basis_of_record": rec.get("basisOfRecord"),
+            "institution": rec.get("institutionCode"),
+            "country": rec.get("country"),
+        })
+
+    return {
+        "species": species_name,
+        "gbif_key": species_key,
+        "n_records": len(records),
+        "records": records,
+    }
+```
+
+### Data Cleaning for SDM
+
+```python
+import pandas as pd
+import numpy as np
+
+def clean_occurrences(records: pd.DataFrame,
+                       study_extent: dict = None,
+                       thin_distance_km: float = 10.0) -> pd.DataFrame:
+    """
+    Clean occurrence records for species distribution modeling.
+    Removes outliers, duplicates, and applies spatial thinning.
+
+    study_extent: {min_lon, max_lon, min_lat, max_lat}
+    thin_distance_km: minimum distance between retained points
+    """
+    df = records.copy()
+
+    # Remove records with missing coordinates
+    df = df.dropna(subset=["latitude", "longitude"])
+
+    # Remove records at (0,0) -- common data error
+    df = df[~((df.latitude == 0) & (df.longitude == 0))]
+
+    # Clip to study extent
+    if study_extent:
+        df = df[
+            (df.longitude >= study_extent["min_lon"]) &
+            (df.longitude <= study_extent["max_lon"]) &
+            (df.latitude >= study_extent["min_lat"]) &
+            (df.latitude <= study_extent["max_lat"])
+        ]
+
+    # Spatial thinning (grid-based)
+    # Convert thinning distance to approximate degrees
+    thin_deg = thin_distance_km / 111.0
+    df["grid_x"] = (df.longitude / thin_deg).astype(int)
+    df["grid_y"] = (df.latitude / thin_deg).astype(int)
+    df = df.drop_duplicates(subset=["grid_x", "grid_y"])
+    df = df.drop(columns=["grid_x", "grid_y"])
+
+    return df.reset_index(drop=True)
+```
+
+## Environmental Predictors
+
+### WorldClim Bioclimatic Variables
+
+The standard predictor set for SDMs:
+
+| Variable | Description | Unit |
+|----------|-------------|------|
+| BIO1 | Annual Mean Temperature | C x 10 |
+| BIO2 | Mean Diurnal Range | C x 10 |
+| BIO4 | Temperature Seasonality | SD x 100 |
+| BIO5 | Max Temperature of Warmest Month | C x 10 |
+| BIO6 | Min Temperature of Coldest Month | C x 10 |
+| BIO12 | Annual Precipitation | mm |
+| BIO13 | Precipitation of Wettest Month | mm |
+| BIO14 | Precipitation of Driest Month | mm |
+| BIO15 | Precipitation Seasonality | CV |
+
+### Extracting Environmental Values
+
+```python
+import rasterio
+from rasterio.sample import sample_gen
+
+def extract_environmental_values(occurrence_coords: np.ndarray,
+                                   raster_paths: dict) -> pd.DataFrame:
+    """
+    Extract environmental variable values at occurrence locations.
+    occurrence_coords: array of (longitude, latitude) pairs
+    raster_paths: {variable_name: filepath} for each predictor raster
+    """
+    env_data = {}
+
+    for var_name, raster_path in raster_paths.items():
+        with rasterio.open(raster_path) as src:
+            values = []
+            for lon, lat in occurrence_coords:
+                row, col = src.index(lon, lat)
+                if 0 <= row < src.height and 0 <= col < src.width:
+                    values.append(float(src.read(1)[row, col]))
+                else:
+                    values.append(np.nan)
+            env_data[var_name] = values
+
+    df = pd.DataFrame(env_data)
+    df["longitude"] = occurrence_coords[:, 0]
+    df["latitude"] = occurrence_coords[:, 1]
+
+    # Remove points with nodata values
+    df = df.replace(src.nodata, np.nan).dropna()
+    return df
+```
+
+## Model Fitting
+
+### MaxEnt (Maximum Entropy)
+
+MaxEnt is the most widely used SDM algorithm for presence-only data:
+
+```python
+import subprocess
+
+def run_maxent(samples_csv: str, env_layers_dir: str,
+                output_dir: str, features: str = "auto",
+                regularization: float = 1.0,
+                n_background: int = 10000) -> dict:
+    """
+    Run MaxEnt species distribution model.
+    samples_csv: CSV with columns species, longitude, latitude
+    env_layers_dir: directory containing .asc raster files
+    output_dir: directory for model outputs
+    """
+    cmd = [
+        "java", "-jar", "maxent.jar",
+        "-s", samples_csv,
+        "-e", env_layers_dir,
+        "-o", output_dir,
+        f"betamultiplier={regularization}",
+        f"maximumbackground={n_background}",
+        "responsecurves=true",
+        "jackknife=true",
+        "writeplotdata=true",
+        "autorun=true",
+    ]
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+
+    # Parse results from maxentResults.csv
+    import csv
+    results_file = f"{output_dir}/maxentResults.csv"
+    with open(results_file) as f:
+        reader = csv.DictReader(f)
+        row = next(reader)
+
+    return {
+        "training_auc": float(row.get("Training AUC", 0)),
+        "test_auc": float(row.get("Test AUC", 0)),
+        "n_training": int(row.get("X Training samples", 0)),
+        "regularized_gain": float(row.get("Regularized training gain", 0)),
+        "important_variables": row.get("Percent contribution", ""),
+    }
+```
+
+### Ensemble SDM with Python
+
+```python
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import cross_val_predict
+from sklearn.metrics import roc_auc_score
+
+def ensemble_sdm(presence_env: pd.DataFrame,
+                  background_env: pd.DataFrame,
+                  predictor_cols: list[str]) -> dict:
+    """
+    Build an ensemble SDM from multiple algorithms.
+    presence_env: environmental values at presence points
+    background_env: environmental values at background/pseudo-absence points
+    """
+    # Prepare data
+    X_pres = presence_env[predictor_cols].values
+    X_bg = background_env[predictor_cols].values
+    X = np.vstack([X_pres, X_bg])
+    y = np.concatenate([np.ones(len(X_pres)), np.zeros(len(X_bg))])
+
+    models = {
+        "random_forest": RandomForestClassifier(n_estimators=500, max_depth=10),
+        "gbm": GradientBoostingClassifier(n_estimators=300, max_depth=5,
+                                            learning_rate=0.05),
+        "logistic": LogisticRegression(max_iter=1000),
+    }
+
+    results = {}
+    predictions = {}
+
+    for name, model in models.items():
+        # Cross-validated predictions
+        cv_pred = cross_val_predict(model, X, y, cv=5, method="predict_proba")[:, 1]
+        auc = roc_auc_score(y, cv_pred)
+
+        model.fit(X, y)
+        results[name] = {"auc": round(auc, 4), "model": model}
+        predictions[name] = cv_pred
+
+    # Weighted ensemble (weight by AUC)
+    total_auc = sum(r["auc"] for r in results.values())
+    ensemble_pred = sum(
+        predictions[name] * results[name]["auc"] / total_auc
+        for name in models
+    )
+    ensemble_auc = roc_auc_score(y, ensemble_pred)
+
+    results["ensemble"] = {"auc": round(ensemble_auc, 4)}
+    return results
+```
+
+## Model Evaluation
+
+### Evaluation Metrics for SDMs
+
+| Metric | Range | Interpretation |
+|--------|-------|---------------|
+| AUC | 0-1 | Discrimination ability (>0.7 useful, >0.8 good) |
+| TSS (True Skill Statistic) | -1 to 1 | Sensitivity + Specificity - 1 |
+| Boyce Index | -1 to 1 | Predicted-to-expected ratio consistency |
+| Kappa | -1 to 1 | Agreement beyond chance |
+
+```python
+def compute_tss(y_true: np.ndarray, y_pred_proba: np.ndarray) -> dict:
+    """
+    Compute TSS (True Skill Statistic) at the optimal threshold.
+    TSS = Sensitivity + Specificity - 1
+    """
+    from sklearn.metrics import roc_curve
+
+    fpr, tpr, thresholds = roc_curve(y_true, y_pred_proba)
+    specificity = 1 - fpr
+    tss_values = tpr + specificity - 1
+
+    optimal_idx = np.argmax(tss_values)
+    return {
+        "tss": round(tss_values[optimal_idx], 4),
+        "optimal_threshold": round(thresholds[optimal_idx], 4),
+        "sensitivity": round(tpr[optimal_idx], 4),
+        "specificity": round(specificity[optimal_idx], 4),
+    }
+```
+
+## Climate Change Projections
+
+### Projecting Habitat Shifts
+
+SDMs can project future suitable habitat under climate scenarios:
+
+1. Fit model on current climate + occurrences
+2. Obtain future climate rasters (CMIP6 SSP scenarios)
+3. Predict suitability on future climate surfaces
+4. Compare current vs future range to quantify shifts
+
+Key considerations:
+- Use multiple GCMs to capture model uncertainty
+- Apply clamping for novel climate combinations
+- Report range change metrics: area gained, area lost, centroid shift
+
+## Tools and Resources
+
+- **MaxEnt**: Maximum entropy SDM (Java, most cited SDM software)
+- **biomod2 (R)**: Ensemble SDM framework with 10+ algorithms
+- **Wallace (R Shiny)**: Interactive SDM workflow application
+- **pygbif / rgbif**: GBIF data access from Python/R
+- **rasterio / terra**: Raster data handling
+- **WorldClim (worldclim.org)**: Global climate data at 1km resolution
+- **CHELSA**: High-resolution climate data (better for mountainous regions)
+- **eBird**: Citizen science bird occurrence data (Cornell Lab)

package/skills/domains/economics/imf-data-api-guide/SKILL.md

@@ -0,0 +1,174 @@
+---
+name: imf-data-api-guide
+description: "Retrieve IMF economic indicators, exchange rates, and country data"
+metadata:
+  openclaw:
+    emoji: "📊"
+    category: "domains"
+    subcategory: "economics"
+    keywords: ["imf", "economics", "macroeconomics", "indicators", "exchange-rates", "gdp"]
+    source: "https://datahelp.imf.org/knowledgebase/articles/667681-using-json-restful-web-service"
+---
+
+# IMF Data API Guide
+
+## Overview
+
+The International Monetary Fund (IMF) provides a free JSON-based REST API for accessing its extensive collection of macroeconomic and financial datasets. The API covers data from virtually every country and territory, spanning indicators such as GDP, inflation, trade balances, exchange rates, government finance statistics, and balance of payments.
+
+For economics researchers, the IMF API is an essential tool for accessing authoritative international economic data without manual downloads. The data powers research in macroeconomics, development economics, international finance, and policy analysis. The API provides access to key datasets including the World Economic Outlook (WEO), International Financial Statistics (IFS), Balance of Payments Statistics (BOP), and the Direction of Trade Statistics (DOTS).
+
+The API requires no authentication and returns JSON data. It uses a hierarchical structure of datasets, indicators, and country/time dimensions.
+
+## Authentication
+
+No authentication is required. The IMF Data API is completely free and open.
+
+```bash
+# No API key needed
+curl "https://www.imf.org/external/datamapper/api/v1/NGDP_RPCH?periods=2024"
+```
+
+## Core Endpoints
+
+### List Available Datasets
+
+```
+GET https://www.imf.org/external/datamapper/api/v1
+```
+
+```bash
+curl -s "https://www.imf.org/external/datamapper/api/v1" | python3 -m json.tool
+```
+
+### List Indicators in a Dataset
+
+```
+GET https://www.imf.org/external/datamapper/api/v1/indicators
+```
+
+### Get Data for an Indicator
+
+```
+GET https://www.imf.org/external/datamapper/api/v1/{indicator}?periods={year}
+```
+
+**Common Indicators:**
+- `NGDP_RPCH`: Real GDP growth (annual percent change)
+- `PCPIPCH`: Inflation, consumer prices (annual percent change)
+- `BCA_NGDPD`: Current account balance (percent of GDP)
+- `GGXWDG_NGDP`: Government gross debt (percent of GDP)
+- `LUR`: Unemployment rate
+
+**Example: Get real GDP growth for all countries in 2024:**
+
+```bash
+curl -s "https://www.imf.org/external/datamapper/api/v1/NGDP_RPCH?periods=2024" \
+  | python3 -m json.tool
+```
+
+### JSON RESTful Web Service (IFS and other databases)
+
+For more granular data, use the Dataflow-based API:
+
+```
+GET http://dataservices.imf.org/REST/SDMX_JSON.svc/CompactData/{database}/{dimensions}?startPeriod={start}&endPeriod={end}
+```
+
+**Example: Monthly CPI data for the US and China:**
+
+```bash
+curl -s "http://dataservices.imf.org/REST/SDMX_JSON.svc/CompactData/IFS/M.US+CN.PCPI_IX?startPeriod=2020&endPeriod=2025" \
+  | python3 -m json.tool
+```
+
+### Python Example: Compare GDP Growth Across Countries
+
+```python
+import requests
+
+DATAMAPPER_URL = "https://www.imf.org/external/datamapper/api/v1"
+
+def get_indicator_data(indicator, periods=None):
+    """Fetch IMF indicator data for all countries."""
+    url = f"{DATAMAPPER_URL}/{indicator}"
+    params = {}
+    if periods:
+        params["periods"] = ",".join(str(p) for p in periods)
+    resp = requests.get(url, params=params)
+    resp.raise_for_status()
+    return resp.json()
+
+# Compare real GDP growth across G7 countries
+data = get_indicator_data("NGDP_RPCH", periods=[2022, 2023, 2024])
+values = data.get("values", {}).get("NGDP_RPCH", {})
+
+g7_codes = ["USA", "GBR", "FRA", "DEU", "JPN", "CAN", "ITA"]
+print("Country | 2022   | 2023   | 2024")
+print("--------|--------|--------|-------")
+for code in g7_codes:
+    country_data = values.get(code, {})
+    row = f"{code:7s}"
+    for year in ["2022", "2023", "2024"]:
+        val = country_data.get(year, "N/A")
+        if isinstance(val, (int, float)):
+            row += f" | {val:5.1f}%"
+        else:
+            row += f" | {str(val):>6s}"
+    print(row)
+```
+
+### Python Example: Exchange Rate Time Series
+
+```python
+import requests
+
+def get_exchange_rates(country_codes, start_year, end_year):
+    """Fetch exchange rate data from IFS database."""
+    codes = "+".join(country_codes)
+    url = (
+        f"http://dataservices.imf.org/REST/SDMX_JSON.svc/"
+        f"CompactData/IFS/A.{codes}.ENDA_XDC_USD_RATE"
+        f"?startPeriod={start_year}&endPeriod={end_year}"
+    )
+    resp = requests.get(url)
+    resp.raise_for_status()
+    return resp.json()
+
+data = get_exchange_rates(["BR", "IN", "ZA"], 2015, 2024)
+series = data.get("CompactData", {}).get("DataSet", {}).get("Series", [])
+for s in series:
+    country = s.get("@REF_AREA", "Unknown")
+    obs = s.get("Obs", [])
+    if isinstance(obs, dict):
+        obs = [obs]
+    print(f"\n{country} exchange rate (LCU per USD):")
+    for o in obs:
+        print(f"  {o.get('@TIME_PERIOD')}: {o.get('@OBS_VALUE')}")
+```
+
+## Common Research Patterns
+
+**Cross-Country Panel Analysis:** Retrieve indicator data for multiple countries and years to construct panel datasets for econometric analysis. Combine GDP growth, inflation, and trade data for gravity models or growth regressions.
+
+**Policy Impact Assessment:** Track economic indicators before and after major policy changes or economic shocks. Compare indicator trajectories across treatment and control country groups.
+
+**Forecasting Benchmarks:** Use IMF WEO projections as baseline forecasts to compare against model predictions. The IMF publishes projections for most indicators several years forward.
+
+**Development Economics:** Access poverty, inequality, and structural indicators for developing economies to study convergence, aid effectiveness, and institutional quality.
+
+## Rate Limits and Best Practices
+
+- **No formal rate limit** published, but limit requests to 1 per second for sustained use
+- **Caching:** IMF data updates infrequently (quarterly/annually); cache aggressively
+- **DataMapper vs SDMX:** The DataMapper API is simpler; the SDMX JSON service is more granular with monthly/quarterly frequency
+- **Country codes:** Use ISO 3-letter codes (USA, GBR, CHN) for the DataMapper API and ISO 2-letter codes (US, GB, CN) for the SDMX service
+- **Large queries:** Fetch data for all countries at once rather than making per-country requests
+- **Error handling:** The API may return empty objects for unavailable country-indicator combinations rather than errors
+
+## References
+
+- IMF Data API Documentation: https://datahelp.imf.org/knowledgebase/articles/667681-using-json-restful-web-service
+- IMF DataMapper: https://www.imf.org/external/datamapper
+- IMF Data Portal: https://data.imf.org/
+- IMF World Economic Outlook: https://www.imf.org/en/Publications/WEO

package/skills/domains/economics/nber-working-papers-api/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: nber-working-papers-api
+description: "Access NBER working papers and economic research datasets"
+metadata:
+  openclaw:
+    emoji: "📈"
+    category: "domains"
+    subcategory: "economics"
+    keywords: ["NBER", "working papers", "economics research", "macroeconomics", "economic policy", "recession dating"]
+    source: "https://www.nber.org/"
+---
+
+# NBER Working Papers and Data API
+
+## Overview
+
+The National Bureau of Economic Research (NBER) is the leading U.S. economics research organization, publishing 1,200+ working papers annually by top economists. NBER papers are among the most cited in economics. The website provides structured access to working papers, researcher profiles, and macroeconomic datasets. Free metadata access; some full text requires subscription.
+
+## Working Papers Access
+
+### RSS/Atom Feeds
+
+```bash
+# Latest working papers feed
+curl "https://www.nber.org/papers.rss"
+
+# Papers by program
+curl "https://www.nber.org/programs/ef/papers.rss"  # Economic Fluctuations
+curl "https://www.nber.org/programs/ls/papers.rss"  # Labor Studies
+curl "https://www.nber.org/programs/io/papers.rss"  # Industrial Organization
+```
+
+### Working Paper Search
+
+```bash
+# Search via NBER website (HTML scraping needed)
+curl "https://www.nber.org/api/v1/working_page_listing/contentType/working_paper/?page=1&perPage=20&q=inflation+expectations"
+
+# Get specific paper metadata
+curl "https://www.nber.org/api/v1/working_page_listing/contentType/working_paper/?page=1&perPage=1&q=w28104"
+```
+
+### NBER Data Portal
+
+```bash
+# Macroeconomic history data
+# Available at: https://data.nber.org/
+
+# Business cycle dates
+curl "https://data.nber.org/data/cycles/business_cycle_dates.json"
+
+# CPS labor data extracts
+# https://data.nber.org/cps/
+```
+
+## NBER Programs
+
+| Code | Program | Focus |
+|------|---------|-------|
+| `ef` | Economic Fluctuations and Growth | Macro, business cycles |
+| `ls` | Labor Studies | Employment, wages |
+| `io` | Industrial Organization | Markets, competition |
+| `pe` | Public Economics | Taxation, spending |
+| `he` | Health Economics | Healthcare markets |
+| `de` | Development Economics | Developing countries |
+| `if` | International Finance | Exchange rates, capital flows |
+| `it` | International Trade | Trade policy |
+| `me` | Monetary Economics | Central banking |
+| `cf` | Corporate Finance | Firm finance |
+| `ap` | Asset Pricing | Financial markets |
+| `ed` | Education | Education economics |
+| `ag` | Aging | Demographics |
+| `ch` | Children | Child welfare |
+| `le` | Law and Economics | Legal institutions |
+| `env` | Environment and Energy | Environmental policy |
+| `pol` | Political Economy | Political institutions |
+
+## Python Usage
+
+```python
+import requests
+from xml.etree import ElementTree
+
+
+def get_latest_papers(program: str = None,
+                      count: int = 20) -> list:
+    """Get latest NBER working papers via RSS."""
+    if program:
+        url = f"https://www.nber.org/programs/{program}/papers.rss"
+    else:
+        url = "https://www.nber.org/papers.rss"
+
+    resp = requests.get(url, timeout=30)
+    resp.raise_for_status()
+
+    root = ElementTree.fromstring(resp.content)
+    papers = []
+    for item in root.findall(".//item")[:count]:
+        papers.append({
+            "title": item.findtext("title", ""),
+            "link": item.findtext("link", ""),
+            "description": item.findtext("description", "")[:300],
+            "pub_date": item.findtext("pubDate", ""),
+        })
+    return papers
+
+
+def search_papers(query: str, page: int = 1,
+                  per_page: int = 20) -> list:
+    """Search NBER working papers."""
+    resp = requests.get(
+        "https://www.nber.org/api/v1/working_page_listing/"
+        "contentType/working_paper/",
+        params={"q": query, "page": page, "perPage": per_page},
+        timeout=30,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    results = []
+    for item in data.get("results", []):
+        results.append({
+            "title": item.get("title"),
+            "authors": item.get("authors", ""),
+            "number": item.get("wp_number", ""),
+            "date": item.get("date", ""),
+            "url": f"https://www.nber.org/papers/{item.get('wp_number', '')}",
+            "abstract": item.get("description", "")[:300],
+            "program": item.get("programs", []),
+        })
+    return results
+
+
+def get_business_cycle_dates() -> list:
+    """Get NBER official business cycle dates."""
+    resp = requests.get(
+        "https://data.nber.org/data/cycles/business_cycle_dates.json",
+        timeout=30,
+    )
+    resp.raise_for_status()
+    return resp.json()
+
+
+# Example: latest macro working papers
+papers = get_latest_papers(program="ef", count=5)
+for p in papers:
+    print(f"{p['title']}")
+    print(f"  {p['link']}")
+
+# Example: search for AI economics papers
+results = search_papers("artificial intelligence labor market")
+for r in results:
+    print(f"[{r['number']}] {r['title']}")
+    print(f"  Authors: {r['authors']}")
+
+# Example: recession dates
+cycles = get_business_cycle_dates()
+for c in cycles[-3:]:
+    print(f"Peak: {c.get('peak')} → Trough: {c.get('trough')}")
+```
+
+## Key Datasets
+
+| Dataset | Description |
+|---------|-------------|
+| Business Cycle Dates | Official US recession start/end dates |
+| CPS Extracts | Current Population Survey labor data |
+| Macrohistory Database | 150 years of macro indicators |
+| Patent Data | Patent citation and classification |
+| Trade Data | Bilateral trade statistics |
+
+## References
+
+- [NBER](https://www.nber.org/)
+- [NBER Working Papers](https://www.nber.org/papers)
+- [NBER Data](https://data.nber.org/)
+- [NBER Programs](https://www.nber.org/programs-projects/programs)