@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/domains/business/innovation-management-guide/SKILL.md

@@ -0,0 +1,257 @@
+---
+name: innovation-management-guide
+description: "Innovation metrics, R&D management research, and technology forecasting"
+metadata:
+  openclaw:
+    emoji: "light-bulb"
+    category: "domains"
+    subcategory: "business"
+    keywords: ["innovation", "r-and-d", "technology-management", "bibliometrics", "diffusion", "strategy"]
+    source: "wentor"
+---
+
+# Innovation Management Guide
+
+A skill for conducting research on innovation management, technology strategy, and R&D performance. Covers innovation measurement, technology forecasting, diffusion modeling, patent-publication linkage, and bibliometric analysis of research portfolios.
+
+## Innovation Measurement
+
+### Key Innovation Metrics
+
+| Metric | Definition | Data Source |
+|--------|-----------|-------------|
+| R&D intensity | R&D spending / Revenue | Annual reports, Compustat |
+| Patent count | Granted patents per year | USPTO, EPO |
+| Citation-weighted patents | Patents weighted by forward citations | PatentsView |
+| New product revenue share | Revenue from products < 3 years old | Internal data |
+| Time to market | Concept to commercial launch | Project records |
+| Innovation efficiency | Revenue from new products / R&D spend | Combined internal data |
+
+### Building an Innovation Scorecard
+
+```python
+import pandas as pd
+import numpy as np
+
+def compute_innovation_scorecard(firm_data: pd.DataFrame) -> pd.DataFrame:
+    """
+    Compute a multi-dimensional innovation scorecard for firms.
+    firm_data columns: firm_id, rd_spend, revenue, patents_filed,
+    patents_granted, citation_count, new_product_revenue, employees
+    """
+    scorecard = pd.DataFrame()
+    scorecard["firm_id"] = firm_data["firm_id"]
+
+    # Input metrics
+    scorecard["rd_intensity"] = firm_data["rd_spend"] / firm_data["revenue"]
+    scorecard["rd_per_employee"] = firm_data["rd_spend"] / firm_data["employees"]
+
+    # Output metrics
+    scorecard["patent_yield"] = (
+        firm_data["patents_granted"] / (firm_data["rd_spend"] / 1e6)
+    )
+    scorecard["citation_impact"] = (
+        firm_data["citation_count"] / firm_data["patents_granted"].clip(lower=1)
+    )
+    scorecard["new_product_share"] = (
+        firm_data["new_product_revenue"] / firm_data["revenue"]
+    )
+
+    # Efficiency
+    scorecard["innovation_efficiency"] = (
+        firm_data["new_product_revenue"] / firm_data["rd_spend"]
+    )
+
+    # Normalize to percentile ranks within the sample
+    for col in scorecard.columns[1:]:
+        scorecard[f"{col}_rank"] = scorecard[col].rank(pct=True)
+
+    # Composite score (equal weights)
+    rank_cols = [c for c in scorecard.columns if c.endswith("_rank")]
+    scorecard["composite_score"] = scorecard[rank_cols].mean(axis=1)
+
+    return scorecard.sort_values("composite_score", ascending=False)
+```
+
+## Technology Diffusion Models
+
+### Bass Diffusion Model
+
+The Bass model is the foundational framework for forecasting technology adoption:
+
+```python
+from scipy.optimize import curve_fit
+
+def bass_model(t: np.ndarray, p: float, q: float, m: float) -> np.ndarray:
+    """
+    Bass diffusion model for cumulative adoption.
+    t: time periods (0, 1, 2, ...)
+    p: coefficient of innovation (external influence)
+    q: coefficient of imitation (internal influence)
+    m: market potential (total eventual adopters)
+    Returns cumulative adoption at each time period.
+    """
+    return m * (1 - np.exp(-(p + q) * t)) / (1 + (q / p) * np.exp(-(p + q) * t))
+
+def bass_incremental(t: np.ndarray, p: float, q: float, m: float) -> np.ndarray:
+    """Bass model incremental (new adopters per period)."""
+    F = bass_model(t, p, q, m) / m
+    f = (p + q * F) * (1 - F)
+    return m * f
+
+def fit_bass_model(adoption_data: np.ndarray) -> dict:
+    """
+    Fit Bass diffusion parameters to observed adoption data.
+    adoption_data: cumulative adoption counts per period.
+    """
+    t = np.arange(len(adoption_data))
+    try:
+        popt, pcov = curve_fit(
+            bass_model, t, adoption_data,
+            p0=[0.01, 0.3, adoption_data[-1] * 2],
+            bounds=([0, 0, adoption_data[-1]], [1, 2, adoption_data[-1] * 10]),
+            maxfev=10000,
+        )
+        return {
+            "p_innovation": round(popt[0], 6),
+            "q_imitation": round(popt[1], 6),
+            "m_potential": round(popt[2], 0),
+            "peak_period": round(np.log(popt[1] / popt[0]) / (popt[0] + popt[1]), 1),
+            "q_p_ratio": round(popt[1] / popt[0], 2),
+        }
+    except RuntimeError:
+        return {"error": "convergence_failed"}
+```
+
+### Typical Bass Parameters by Technology Category
+
+| Technology | p (innovation) | q (imitation) | q/p ratio |
+|-----------|---------------|---------------|-----------|
+| Consumer electronics | 0.01-0.03 | 0.3-0.5 | 10-50 |
+| Enterprise software | 0.005-0.02 | 0.2-0.4 | 10-80 |
+| Medical devices | 0.001-0.01 | 0.1-0.3 | 10-300 |
+| Social media platforms | 0.03-0.10 | 0.5-0.8 | 5-25 |
+
+## Bibliometric Analysis of R&D Portfolios
+
+### Publication Portfolio Analysis
+
+```python
+def analyze_research_portfolio(publications: pd.DataFrame) -> dict:
+    """
+    Bibliometric analysis of an organization's research portfolio.
+    publications columns: doi, title, year, journal, citations,
+    fields (list), authors (list), affiliations (list)
+    """
+    # Publication trend
+    annual_pubs = publications.groupby("year").size()
+
+    # Citation impact
+    citation_stats = {
+        "total_citations": publications.citations.sum(),
+        "mean_citations": publications.citations.mean(),
+        "median_citations": publications.citations.median(),
+        "h_index": compute_h_index(publications.citations.values),
+    }
+
+    # Research field distribution
+    all_fields = []
+    for fields in publications.fields:
+        all_fields.extend(fields)
+    field_dist = pd.Series(all_fields).value_counts().head(20)
+
+    # Collaboration patterns
+    collab_rate = publications.affiliations.apply(
+        lambda x: len(set(x)) > 1
+    ).mean()
+
+    return {
+        "total_publications": len(publications),
+        "annual_trend": annual_pubs.to_dict(),
+        "citation_impact": citation_stats,
+        "top_fields": field_dist.to_dict(),
+        "collaboration_rate": round(collab_rate, 3),
+    }
+
+def compute_h_index(citations: np.ndarray) -> int:
+    """Compute h-index from an array of citation counts."""
+    sorted_cites = np.sort(citations)[::-1]
+    h = 0
+    for i, c in enumerate(sorted_cites):
+        if c >= i + 1:
+            h = i + 1
+        else:
+            break
+    return h
+```
+
+## Technology Forecasting Methods
+
+### S-Curve Analysis
+
+Technology performance typically follows an S-curve pattern:
+
+1. **Emergence phase**: Slow initial growth, high uncertainty
+2. **Growth phase**: Rapid performance improvement, competitive investment
+3. **Maturity phase**: Diminishing returns, incremental improvement
+4. **Saturation/decline**: Physical or market limits reached
+
+### Forecasting Approaches
+
+| Method | Time Horizon | Data Requirements | Best For |
+|--------|-------------|-------------------|----------|
+| Delphi method | 5-30 years | Expert panels | Emerging technologies |
+| Trend extrapolation | 2-10 years | Historical time series | Incremental innovation |
+| Scenario planning | 5-20 years | Qualitative analysis | Strategic uncertainty |
+| Patent analysis | 3-10 years | Patent databases | Technology landscape |
+| Bibliometric mapping | 2-5 years | Publication data | Research front detection |
+
+## Open Innovation Research
+
+### Measuring Open Innovation
+
+```python
+def open_innovation_metrics(firm_patents: pd.DataFrame,
+                             firm_publications: pd.DataFrame,
+                             alliances: pd.DataFrame) -> dict:
+    """
+    Compute open innovation indicators for a firm.
+    """
+    # Inbound openness: external knowledge sourcing
+    external_collab_pubs = firm_publications[
+        firm_publications.external_coauthors > 0
+    ]
+    inbound_ratio = len(external_collab_pubs) / max(len(firm_publications), 1)
+
+    # Outbound openness: technology licensing, spin-offs
+    licensed_patents = firm_patents[firm_patents.licensed == True]
+    outbound_ratio = len(licensed_patents) / max(len(firm_patents), 1)
+
+    # Network diversity (alliance partner variety)
+    partner_industries = alliances.partner_industry.nunique()
+
+    return {
+        "inbound_openness": round(inbound_ratio, 3),
+        "outbound_openness": round(outbound_ratio, 3),
+        "alliance_count": len(alliances),
+        "partner_diversity": partner_industries,
+    }
+```
+
+## Key Journals and Conferences
+
+- *Research Policy*
+- *Technovation*
+- *Journal of Product Innovation Management*
+- *R&D Management*
+- *Strategic Management Journal*
+- *Academy of Management Conference (TIM division)*
+
+## Tools and Resources
+
+- **Compustat / WRDS**: Financial data including R&D expenditure
+- **Web of Science / Scopus**: Bibliometric data for publication analysis
+- **PatentsView**: Patent data with inventor and assignee disambiguation
+- **VOSviewer**: Bibliometric network visualization
+- **Gephi**: Network analysis and visualization
+- **Bass forecasting tools**: R diffusion package, Python implementations

package/skills/domains/business/operations-research-guide/SKILL.md

@@ -0,0 +1,258 @@
+---
+name: operations-research-guide
+description: "Optimization and operations research methods for business and logistics"
+metadata:
+  openclaw:
+    emoji: "gear"
+    category: "domains"
+    subcategory: "business"
+    keywords: ["optimization", "operations-research", "linear-programming", "scheduling", "supply-chain", "simulation"]
+    source: "wentor"
+---
+
+# Operations Research Guide
+
+A skill for applying operations research (OR) methods to business, logistics, and resource allocation problems. Covers linear programming, integer programming, scheduling, network optimization, simulation, and decision analysis using Python optimization libraries.
+
+## Linear Programming
+
+### Problem Formulation and Solving
+
+```python
+from scipy.optimize import linprog
+import numpy as np
+
+def solve_production_planning():
+    """
+    Example: A factory produces two products (A and B).
+    Product A: profit $40, uses 2h labor + 1kg material
+    Product B: profit $30, uses 1h labor + 2kg material
+    Constraints: 100h labor available, 80kg material available
+    Maximize total profit.
+    """
+    # linprog minimizes, so negate for maximization
+    c = [-40, -30]  # objective coefficients (negated)
+
+    # Inequality constraints: A_ub @ x <= b_ub
+    A_ub = [
+        [2, 1],   # labor constraint
+        [1, 2],   # material constraint
+    ]
+    b_ub = [100, 80]
+
+    # Non-negativity bounds
+    bounds = [(0, None), (0, None)]
+
+    result = linprog(c, A_ub=A_ub, b_ub=b_ub, bounds=bounds, method="highs")
+
+    return {
+        "product_A": result.x[0],
+        "product_B": result.x[1],
+        "max_profit": -result.fun,
+        "status": "optimal" if result.success else "infeasible",
+    }
+```
+
+### Using PuLP for Readable Models
+
+```python
+from pulp import LpProblem, LpMaximize, LpVariable, lpSum, value
+
+def workforce_scheduling():
+    """
+    Workforce scheduling: minimize staffing cost while meeting
+    demand for each day of the week. Workers work 5 consecutive days.
+    """
+    days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+    demand = [17, 13, 15, 19, 14, 16, 11]
+    cost_per_worker = 1  # uniform cost
+
+    prob = LpProblem("workforce_scheduling", LpMaximize)
+
+    # x[i] = number of workers starting on day i
+    x = {i: LpVariable(f"start_{days[i]}", lowBound=0, cat="Integer")
+         for i in range(7)}
+
+    # Minimize total workers
+    prob += -lpSum(x[i] for i in range(7))
+
+    # Each day, workers starting on days [d-4, d-3, ..., d] are available
+    for d in range(7):
+        workers_available = lpSum(x[(d - j) % 7] for j in range(5))
+        prob += workers_available >= demand[d], f"demand_{days[d]}"
+
+    prob.solve()
+
+    return {
+        "status": prob.status,
+        "schedule": {days[i]: int(value(x[i])) for i in range(7)},
+        "total_workers": int(sum(value(x[i]) for i in range(7))),
+    }
+```
+
+## Integer and Mixed-Integer Programming
+
+### Vehicle Routing Problem
+
+```python
+from itertools import combinations
+
+def solve_tsp_mtz(distances: np.ndarray) -> dict:
+    """
+    Solve the Traveling Salesman Problem using Miller-Tucker-Zemlin formulation.
+    distances: n x n distance matrix
+    Returns optimal tour and total distance.
+    """
+    from pulp import LpProblem, LpMinimize, LpVariable, LpBinary, lpSum, value
+
+    n = len(distances)
+    prob = LpProblem("TSP", LpMinimize)
+
+    # Binary variables: x[i][j] = 1 if edge (i,j) in tour
+    x = {(i, j): LpVariable(f"x_{i}_{j}", cat=LpBinary)
+         for i in range(n) for j in range(n) if i != j}
+
+    # Subtour elimination variables
+    u = {i: LpVariable(f"u_{i}", lowBound=1, upBound=n - 1)
+         for i in range(1, n)}
+
+    # Objective: minimize total distance
+    prob += lpSum(distances[i][j] * x[i, j] for i, j in x)
+
+    # Each city visited exactly once
+    for i in range(n):
+        prob += lpSum(x[i, j] for j in range(n) if j != i) == 1
+        prob += lpSum(x[j, i] for j in range(n) if j != i) == 1
+
+    # MTZ subtour elimination
+    for i in range(1, n):
+        for j in range(1, n):
+            if i != j:
+                prob += u[i] - u[j] + (n - 1) * x[i, j] <= n - 2
+
+    prob.solve()
+
+    # Extract tour
+    tour = [0]
+    current = 0
+    for _ in range(n - 1):
+        for j in range(n):
+            if j != current and (current, j) in x and value(x[current, j]) > 0.5:
+                tour.append(j)
+                current = j
+                break
+
+    return {
+        "tour": tour,
+        "total_distance": value(prob.objective),
+    }
+```
+
+## Queuing Theory
+
+### M/M/c Queue Analysis
+
+```python
+from math import factorial, exp
+
+def mmc_queue(arrival_rate: float, service_rate: float,
+              n_servers: int) -> dict:
+    """
+    Analyze an M/M/c queue (Poisson arrivals, exponential service, c servers).
+    arrival_rate: lambda (customers per unit time)
+    service_rate: mu (customers served per unit time per server)
+    n_servers: c (number of parallel servers)
+    """
+    rho = arrival_rate / (n_servers * service_rate)
+
+    if rho >= 1:
+        return {"stable": False, "utilization": rho}
+
+    # Erlang C formula: probability of waiting
+    a = arrival_rate / service_rate
+    sum_terms = sum(a ** k / factorial(k) for k in range(n_servers))
+    erlang_c = (a ** n_servers / factorial(n_servers)) / (
+        (a ** n_servers / factorial(n_servers)) + (1 - rho) * sum_terms
+    )
+
+    # Performance metrics
+    Lq = erlang_c * rho / (1 - rho)         # avg queue length
+    Wq = Lq / arrival_rate                    # avg wait time
+    W = Wq + 1 / service_rate                 # avg time in system
+    L = arrival_rate * W                      # avg number in system
+
+    return {
+        "stable": True,
+        "utilization": round(rho, 4),
+        "prob_wait": round(erlang_c, 4),
+        "avg_queue_length": round(Lq, 4),
+        "avg_wait_time": round(Wq, 4),
+        "avg_system_time": round(W, 4),
+        "avg_in_system": round(L, 4),
+    }
+```
+
+## Simulation Methods
+
+### Discrete-Event Simulation
+
+```python
+import simpy
+import random
+
+def simulate_service_center(n_servers: int, arrival_rate: float,
+                             service_rate: float, sim_time: float = 480):
+    """
+    Discrete-event simulation of a service center using SimPy.
+    sim_time: simulation duration in minutes (default 8-hour day).
+    """
+    wait_times = []
+
+    def customer(env, server):
+        arrival_time = env.now
+        with server.request() as req:
+            yield req
+            wait = env.now - arrival_time
+            wait_times.append(wait)
+            yield env.timeout(random.expovariate(service_rate))
+
+    def customer_generator(env, server):
+        customer_id = 0
+        while True:
+            yield env.timeout(random.expovariate(arrival_rate))
+            customer_id += 1
+            env.process(customer(env, server))
+
+    env = simpy.Environment()
+    server = simpy.Resource(env, capacity=n_servers)
+    env.process(customer_generator(env, server))
+    env.run(until=sim_time)
+
+    return {
+        "customers_served": len(wait_times),
+        "avg_wait": np.mean(wait_times) if wait_times else 0,
+        "max_wait": max(wait_times) if wait_times else 0,
+        "pct_waited": sum(1 for w in wait_times if w > 0) / len(wait_times) * 100,
+    }
+```
+
+## Decision Analysis
+
+### Multi-Criteria Decision Making
+
+| Method | Description | Best For |
+|--------|-------------|----------|
+| AHP (Analytic Hierarchy Process) | Pairwise comparison matrix | Structured group decisions |
+| TOPSIS | Distance to ideal/anti-ideal solution | Ranking alternatives |
+| Weighted scoring | Simple weighted sum | Quick comparisons |
+| Decision trees | Sequential decision under uncertainty | Multi-stage problems |
+
+## Tools and Libraries
+
+- **PuLP**: Python LP/MIP modeling with multiple solver backends
+- **OR-Tools (Google)**: Constraint programming, routing, scheduling
+- **Gurobi / CPLEX**: Commercial high-performance MIP solvers (free academic licenses)
+- **SimPy**: Python discrete-event simulation framework
+- **SciPy optimize**: Linear programming, nonlinear optimization
+- **Pyomo**: Algebraic modeling language for optimization in Python
+- **AMPL**: Commercial algebraic modeling language

package/skills/domains/business/xpert-bi-guide/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: xpert-bi-guide
+description: "AI business intelligence agent with NL-to-SQL and dashboards"
+metadata:
+  openclaw:
+    emoji: "📊"
+    category: "domains"
+    subcategory: "business"
+    keywords: ["business intelligence", "NL-to-SQL", "dashboard", "data analysis", "BI agent", "analytics"]
+    source: "https://github.com/xpert-ai/xpert"
+---
+
+# Xpert BI Agent Guide
+
+## Overview
+
+Xpert is an AI-powered business intelligence agent that converts natural language questions into SQL queries, generates interactive dashboards, and provides data-driven insights. Connects to databases (PostgreSQL, MySQL, BigQuery) and produces visualizations with explanations. Useful for researchers analyzing institutional data and business analytics.
+
+## Features
+
+```markdown
+### Core Capabilities
+- **NL-to-SQL**: Convert questions to SQL queries
+- **Auto-visualization**: Choose appropriate chart types
+- **Dashboard generation**: Multi-chart interactive dashboards
+- **Insight extraction**: Statistical findings from data
+- **Report generation**: Narrative reports with charts
+
+### Supported Databases
+- PostgreSQL, MySQL, SQLite
+- BigQuery, Snowflake, Redshift
+- CSV/Excel files (auto-loaded to SQLite)
+```
+
+## Usage
+
+```python
+from xpert import XpertBI
+
+bi = XpertBI(
+    database_url="postgresql://user:pass@localhost/research_db",
+    llm_provider="anthropic",
+)
+
+# Natural language query
+result = bi.ask(
+    "What is the publication trend by department over "
+    "the last 5 years?"
+)
+
+print(result.sql)       # Generated SQL query
+print(result.data)      # Query results as DataFrame
+result.chart.save("pub_trend.png")  # Auto-generated chart
+print(result.insight)   # "Publications increased 23% overall..."
+```
+
+## Dashboard Generation
+
+```python
+# Generate multi-chart dashboard
+dashboard = bi.create_dashboard(
+    title="Research Output Analysis",
+    questions=[
+        "Publications per year by department",
+        "Top 10 authors by citation count",
+        "Funding amount vs publication output correlation",
+        "Journal distribution of publications",
+    ],
+)
+
+dashboard.save("research_dashboard.html")
+```
+
+## Use Cases
+
+1. **Research analytics**: Analyze publication and citation data
+2. **Institutional reporting**: Department-level research metrics
+3. **Grant analysis**: Funding patterns and outcomes
+4. **Data exploration**: Quick BI on research databases
+5. **Teaching**: Demonstrate data analysis concepts
+
+## References
+
+- [Xpert GitHub](https://github.com/xpert-ai/xpert)

package/skills/domains/chemistry/cactus-cheminformatics-guide/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: cactus-cheminformatics-guide
+description: "PNNL cheminformatics LLM agent for molecular analysis"
+metadata:
+  openclaw:
+    emoji: "🌵"
+    category: "domains"
+    subcategory: "chemistry"
+    keywords: ["CACTUS", "cheminformatics", "PNNL", "molecular analysis", "LLM chemistry", "chemical agent"]
+    source: "https://github.com/pnnl/cactus"
+---
+
+# CACTUS Cheminformatics Agent Guide
+
+## Overview
+
+CACTUS is a cheminformatics LLM agent developed at Pacific Northwest National Laboratory (PNNL) that provides AI-assisted molecular analysis, property prediction, and chemical reasoning. It wraps RDKit, molecular databases, and ML models behind a conversational interface, enabling researchers to query molecular properties, perform similarity searches, and run cheminformatics workflows using natural language.
+
+## Usage
+
+```python
+from cactus import ChemAgent
+
+agent = ChemAgent(llm_provider="anthropic")
+
+# Natural language chemistry queries
+result = agent.ask(
+    "What is the molecular weight and LogP of aspirin? "
+    "Is it drug-like by Lipinski's rules?"
+)
+print(result.answer)
+# Aspirin (CC(=O)Oc1ccccc1C(=O)O):
+# MW: 180.16, LogP: 1.24
+# Lipinski: PASS (MW<500, LogP<5, HBD=1≤5, HBA=4≤10)
+
+# Molecular property calculation
+props = agent.calculate_properties(
+    smiles="CC(=O)Oc1ccccc1C(=O)O",
+    properties=["mw", "logp", "tpsa", "hbd", "hba", "rotatable"],
+)
+print(props)
+```
+
+## Similarity Search
+
+```python
+# Find similar molecules
+similar = agent.similarity_search(
+    query_smiles="CC(=O)Oc1ccccc1C(=O)O",  # Aspirin
+    database="chembl",
+    threshold=0.7,  # Tanimoto similarity
+    max_results=10,
+)
+
+for mol in similar:
+    print(f"{mol.name}: {mol.smiles} "
+          f"(similarity: {mol.tanimoto:.3f})")
+```
+
+## Substructure Analysis
+
+```python
+# Substructure search
+matches = agent.substructure_search(
+    pattern="c1ccccc1C(=O)O",  # Benzoic acid motif
+    database="drugbank",
+    max_results=20,
+)
+
+# Functional group identification
+groups = agent.identify_functional_groups(
+    smiles="CC(=O)Oc1ccccc1C(=O)O"
+)
+# ["ester", "carboxylic_acid", "aromatic_ring"]
+```
+
+## Use Cases
+
+1. **Molecular analysis**: Property calculation via natural language
+2. **Drug screening**: Lipinski/Veber rule checking
+3. **Similarity search**: Find analogs in chemical databases
+4. **Structure analysis**: Substructure and functional group ID
+5. **Chemical education**: Interactive chemistry exploration
+
+## References
+
+- [CACTUS GitHub](https://github.com/pnnl/cactus)
+- [RDKit](https://www.rdkit.org/)
+- [PNNL](https://www.pnnl.gov/)