@nahisaho/satori 0.13.0 → 0.15.0

package/src/.github/skills/scientific-string-network-api/SKILL.md

@@ -0,0 +1,376 @@
+---
+name: scientific-string-network-api
+description: |
+  STRING/BioGRID/STITCH ネットワーク解析スキル。STRING タンパク質相互作用
+  ネットワーク直接 API、BioGRID 実験的 PPI、STITCH 化学-タンパク質ネットワーク、
+  ネットワークトポロジー解析・コミュニティ検出・機能濃縮統合パイプライン。
+---
+
+# Scientific STRING Network API
+
+STRING v12 / BioGRID / STITCH API を活用した PPI・化合物-タンパク質
+ネットワーク解析パイプラインを提供する。既存の protein-interaction-network
+スキル (IntAct/HumanBase) を補完し、STRING 直接 API ベースの高度な
+ネットワーク分析を統合。
+
+## When to Use
+
+- STRING API でタンパク質相互作用ネットワークを直接構築するとき
+- BioGRID から実験的エビデンスベースの PPI を取得するとき
+- STITCH で化合物-タンパク質間ネットワークを検索するとき
+- ネットワークトポロジー指標 (次数分布・媒介中心性) を計算するとき
+- PPI ネットワーク上でコミュニティ検出を行うとき
+- 機能濃縮解析 (STRING enrichment) をネットワーク上で実行するとき
+
+---
+
+## Quick Start
+
+## 1. STRING PPI ネットワーク取得
+
+```python
+import requests
+import pandas as pd
+import networkx as nx
+
+STRING_API = "https://string-db.org/api"
+OUTPUT_FORMAT = "json"
+
+
+def get_string_network(proteins, species=9606, score_threshold=400,
+                       network_type="functional", limit=50):
+    """
+    STRING PPI ネットワーク取得。
+
+    Parameters:
+        proteins: list — タンパク質名リスト (例: ["TP53", "MDM2", "BRCA1"])
+        species: int — NCBI Taxonomy ID (9606=human)
+        score_threshold: int — 信頼スコア閾値 (0-1000)
+        network_type: str — "functional" or "physical"
+        limit: int — interactor 最大数
+
+    ToolUniverse:
+        STRING_get_protein_interactions(
+            protein_ids=proteins, species=species,
+            confidence_score=score_threshold/1000,
+            network_type=network_type, limit=limit
+        )
+    """
+    url = f"{STRING_API}/{OUTPUT_FORMAT}/network"
+    params = {
+        "identifiers": "\r".join(proteins),
+        "species": species,
+        "required_score": score_threshold,
+        "network_type": network_type,
+        "limit": limit,
+    }
+
+    resp = requests.post(url, data=params)
+    resp.raise_for_status()
+    interactions = resp.json()
+
+    rows = []
+    for i in interactions:
+        rows.append({
+            "protein_a": i.get("preferredName_A"),
+            "protein_b": i.get("preferredName_B"),
+            "combined_score": i.get("score"),
+            "nscore": i.get("nscore"),
+            "fscore": i.get("fscore"),
+            "pscore": i.get("pscore"),
+            "ascore": i.get("ascore"),
+            "escore": i.get("escore"),
+            "dscore": i.get("dscore"),
+            "tscore": i.get("tscore"),
+        })
+
+    df = pd.DataFrame(rows)
+    print(f"STRING network: {len(df)} interactions "
+          f"(score ≥ {score_threshold/1000})")
+    return df
+```
+
+## 2. BioGRID 実験的 PPI 取得
+
+```python
+def get_biogrid_interactions(genes, organism=9606, evidence_type=None,
+                             api_key="YOUR_KEY", limit=500):
+    """
+    BioGRID 実験的 PPI データ取得。
+
+    Parameters:
+        genes: list — 遺伝子名リスト
+        organism: int — NCBI Taxonomy ID
+        evidence_type: str — "physical" or "genetic"
+        api_key: str — BioGRID API key (https://webservice.thebiogrid.org)
+        limit: int — 最大取得数
+
+    ToolUniverse:
+        BioGRID_get_interactions(
+            gene_names=genes, organism=organism,
+            interaction_type=evidence_type, limit=limit
+        )
+    """
+    url = "https://webservice.thebiogrid.org/interactions"
+    params = {
+        "accessKey": api_key,
+        "geneList": "|".join(genes),
+        "organism": organism,
+        "format": "json",
+        "max": limit,
+        "searchNames": "true",
+        "includeInteractors": "true",
+    }
+    if evidence_type:
+        params["interSpeciesExcluded"] = "true"
+
+    resp = requests.get(url, params=params)
+    resp.raise_for_status()
+    data = resp.json()
+
+    rows = []
+    for _, interaction in data.items():
+        rows.append({
+            "gene_a": interaction.get("OFFICIAL_SYMBOL_A"),
+            "gene_b": interaction.get("OFFICIAL_SYMBOL_B"),
+            "experimental_system": interaction.get("EXPERIMENTAL_SYSTEM"),
+            "throughput": interaction.get("THROUGHPUT"),
+            "pubmed_id": interaction.get("PUBMED_ID"),
+            "source_db": "BioGRID",
+        })
+
+    df = pd.DataFrame(rows)
+    print(f"BioGRID: {len(df)} interactions for {genes}")
+    return df
+```
+
+## 3. STITCH 化合物-タンパク質ネットワーク
+
+```python
+def get_stitch_interactions(identifiers, species=9606, score=400, limit=20):
+    """
+    STITCH 化合物-タンパク質相互作用取得。
+
+    Parameters:
+        identifiers: list — CID (化合物) または遺伝子名リスト
+        species: int — NCBI Taxonomy ID
+        score: int — 信頼スコア閾値
+        limit: int — 最大結果数
+
+    ToolUniverse:
+        STITCH_get_chemical_protein_interactions(
+            identifiers=identifiers, species=species,
+            required_score=score, limit=limit
+        )
+        STITCH_get_interaction_partners(identifiers=identifiers)
+        STITCH_resolve_identifier(identifiers=identifiers)
+    """
+    url = f"https://stitch.embl.de/api/{OUTPUT_FORMAT}/interactionsList"
+    params = {
+        "identifiers": "\r".join(identifiers),
+        "species": species,
+        "required_score": score,
+        "limit": limit,
+    }
+
+    resp = requests.post(url, data=params)
+    resp.raise_for_status()
+    interactions = resp.json()
+
+    rows = []
+    for i in interactions:
+        rows.append({
+            "interactor_a": i.get("preferredName_A", i.get("stringId_A")),
+            "interactor_b": i.get("preferredName_B", i.get("stringId_B")),
+            "combined_score": i.get("score"),
+            "is_chemical": "CID" in str(i.get("stringId_A", ""))
+                or "CID" in str(i.get("stringId_B", "")),
+        })
+
+    df = pd.DataFrame(rows)
+    print(f"STITCH: {len(df)} chemical-protein interactions")
+    return df
+```
+
+## 4. ネットワーク構築 & トポロジー解析
+
+```python
+def build_network(interaction_df, source_col="protein_a", target_col="protein_b",
+                  weight_col="combined_score"):
+    """
+    NetworkX グラフ構築 & トポロジー解析。
+
+    Parameters:
+        interaction_df: DataFrame — 相互作用データ
+        source_col, target_col: str — ノードカラム名
+        weight_col: str — エッジ重みカラム名
+    """
+    G = nx.Graph()
+    for _, row in interaction_df.iterrows():
+        G.add_edge(
+            row[source_col], row[target_col],
+            weight=row.get(weight_col, 1.0),
+        )
+
+    # トポロジー指標
+    degree = dict(G.degree())
+    betweenness = nx.betweenness_centrality(G)
+    closeness = nx.closeness_centrality(G)
+    clustering = nx.clustering(G)
+
+    metrics = pd.DataFrame({
+        "node": list(degree.keys()),
+        "degree": list(degree.values()),
+        "betweenness": [betweenness[n] for n in degree],
+        "closeness": [closeness[n] for n in degree],
+        "clustering": [clustering[n] for n in degree],
+    }).sort_values("betweenness", ascending=False)
+
+    print(f"Network: {G.number_of_nodes()} nodes, "
+          f"{G.number_of_edges()} edges, "
+          f"density={nx.density(G):.4f}")
+    return G, metrics
+```
+
+## 5. コミュニティ検出
+
+```python
+from networkx.algorithms.community import greedy_modularity_communities
+
+
+def detect_communities(G, resolution=1.0):
+    """
+    ネットワーク上のコミュニティ (モジュール) 検出。
+
+    Parameters:
+        G: nx.Graph — ネットワークグラフ
+        resolution: float — 解像度パラメータ
+    """
+    communities = list(greedy_modularity_communities(G, resolution=resolution))
+    modularity = nx.algorithms.community.modularity(G, communities)
+
+    comm_data = []
+    for i, comm in enumerate(communities):
+        for node in comm:
+            comm_data.append({"node": node, "community": i})
+
+    df = pd.DataFrame(comm_data)
+    print(f"Communities: {len(communities)} detected, "
+          f"modularity={modularity:.4f}")
+    return df, modularity
+```
+
+## 6. STRING 機能濃縮解析
+
+```python
+def string_enrichment(proteins, species=9606):
+    """
+    STRING API 機能濃縮解析 (GO/KEGG/Reactome/InterPro)。
+
+    Parameters:
+        proteins: list — タンパク質名リスト
+        species: int — NCBI Taxonomy ID
+    """
+    url = f"{STRING_API}/{OUTPUT_FORMAT}/enrichment"
+    params = {
+        "identifiers": "\r".join(proteins),
+        "species": species,
+    }
+
+    resp = requests.post(url, data=params)
+    resp.raise_for_status()
+    enrichment = resp.json()
+
+    rows = []
+    for e in enrichment:
+        rows.append({
+            "category": e.get("category"),
+            "term": e.get("term"),
+            "description": e.get("description"),
+            "p_value": e.get("p_value"),
+            "fdr": e.get("fdr"),
+            "number_of_genes": e.get("number_of_genes"),
+            "input_genes": e.get("inputGenes", ""),
+        })
+
+    df = pd.DataFrame(rows)
+    if not df.empty:
+        df = df.sort_values("fdr")
+    print(f"Enrichment: {len(df)} terms, "
+          f"{df[df['fdr'] < 0.05].shape[0]} significant (FDR<0.05)")
+    return df
+```
+
+## 7. 統合 PPI 解析パイプライン
+
+```python
+def integrated_ppi_pipeline(genes, species=9606, score=700):
+    """
+    STRING + BioGRID + STITCH 統合 PPI パイプライン。
+
+    Pipeline:
+        STRING network → BioGRID validation → topology → communities →
+        enrichment
+    """
+    # STRING ネットワーク
+    string_df = get_string_network(genes, species, score)
+
+    # ネットワーク構築 & トポロジー
+    G, metrics = build_network(string_df)
+
+    # コミュニティ検出
+    comm_df, modularity = detect_communities(G)
+
+    # STRING 濃縮解析
+    all_nodes = list(G.nodes())
+    enrichment = string_enrichment(all_nodes[:500], species)
+
+    result = {
+        "n_nodes": G.number_of_nodes(),
+        "n_edges": G.number_of_edges(),
+        "density": round(nx.density(G), 4),
+        "n_communities": comm_df["community"].nunique(),
+        "modularity": round(modularity, 4),
+        "hub_genes": metrics.head(10)["node"].tolist(),
+        "n_enriched_terms": len(enrichment[enrichment["fdr"] < 0.05])
+            if not enrichment.empty else 0,
+    }
+
+    print(f"\n=== Integrated PPI Pipeline ===")
+    print(f"Nodes: {result['n_nodes']}, Edges: {result['n_edges']}")
+    print(f"Hub genes: {', '.join(result['hub_genes'][:5])}")
+    return result
+```
+
+---
+
+## パイプライン統合
+
+```
+drug-target-profiling → string-network-api → pathway-enrichment
+  (候補ターゲット)       (STRING PPI 構築)     (GO/KEGG 濃縮)
+        │                       │                    ↓
+protein-interaction ───┘        │           ontology-enrichment
+  (IntAct/HumanBase)            ↓             (EFO/Enrichr)
+                       network-analysis
+                       (既存スキル補完)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `results/string_network.csv` | STRING PPI ネットワーク | → network-analysis |
+| `results/ppi_topology.csv` | トポロジー指標 | → drug-target-profiling |
+| `results/ppi_communities.csv` | コミュニティ割当 | → pathway-enrichment |
+| `results/string_enrichment.csv` | 機能濃縮結果 | → ontology-enrichment |
+
+## 利用可能ツール (ToolUniverse SMCP)
+
+| ツール名 | 用途 |
+|---------|------|
+| `STRING_get_protein_interactions` | STRING PPI 取得 |
+| `BioGRID_get_interactions` | BioGRID 実験的 PPI |
+| `STITCH_get_chemical_protein_interactions` | STITCH 化合物-タンパク質 |
+| `STITCH_get_interaction_partners` | STITCH 相互作用パートナー |
+| `STITCH_resolve_identifier` | STITCH ID 解決 |

package/src/.github/skills/scientific-symbolic-mathematics/SKILL.md

@@ -0,0 +1,277 @@
+---
+name: scientific-symbolic-mathematics
+description: |
+  記号数学スキル。SymPy による解析的微積分・線形代数・微分方程式求解、
+  記号式の LaTeX 変換、数値計算との統合、科学モデリング用
+  記号計算パイプライン。
+---
+
+# Scientific Symbolic Mathematics
+
+SymPy を中心とした記号数学 (Computer Algebra System)
+パイプラインを提供する。
+
+## When to Use
+
+- 微分方程式を解析的に解くとき
+- 数式の記号的微分・積分を行うとき
+- 行列の固有値・固有ベクトルを記号的に求めるとき
+- 科学モデルのパラメータに関する感度解析を記号的に行うとき
+- 数式を LaTeX 形式に変換するとき
+- 記号解と数値解を比較検証するとき
+
+---
+
+## Quick Start
+
+## 1. 微分方程式の解析解
+
+```python
+import sympy as sp
+from sympy import (
+    symbols, Function, Eq, dsolve, classify_ode,
+    exp, sin, cos, sqrt, pi, oo, integrate, diff,
+    Matrix, latex, simplify, factor, expand, solve,
+    Rational, Sum, Product, series,
+)
+import numpy as np
+
+
+def solve_ode(ode_expr, dependent_var, independent_var, ics=None):
+    """
+    常微分方程式の解析解。
+
+    Parameters:
+        ode_expr: sympy.Eq — ODE (e.g., Eq(f(x).diff(x, 2) + f(x), 0))
+        dependent_var: sympy.Function — 従属変数
+        independent_var: sympy.Symbol — 独立変数
+        ics: dict — 初期条件 {f(0): 1, f'(0): 0}
+
+    K-Dense: sympy — Symbolic mathematics
+    """
+    # Classify ODE
+    classification = classify_ode(ode_expr, dependent_var(independent_var))
+    print(f"ODE classification: {classification[:3]}")
+
+    # Solve
+    solution = dsolve(ode_expr, dependent_var(independent_var), ics=ics)
+
+    print(f"Solution: {solution}")
+    print(f"LaTeX: {latex(solution)}")
+    return solution
+
+
+# Example: damped harmonic oscillator
+x, t, omega, gamma = symbols("x t omega gamma", positive=True)
+f = Function("f")
+
+# f''(t) + 2γf'(t) + ω²f(t) = 0
+damped_ode = Eq(f(t).diff(t, 2) + 2*gamma*f(t).diff(t) + omega**2*f(t), 0)
+```
+
+## 2. 記号的微積分
+
+```python
+def symbolic_calculus(expr, var, operations=None):
+    """
+    記号的微積分操作。
+
+    Parameters:
+        expr: sympy expression — 数式
+        var: sympy.Symbol — 変数
+        operations: list — ["diff", "integrate", "series", "limit"]
+    """
+    if operations is None:
+        operations = ["diff", "integrate"]
+
+    results = {}
+
+    if "diff" in operations:
+        deriv = diff(expr, var)
+        results["derivative"] = {"expr": deriv, "latex": latex(deriv)}
+        print(f"d/d{var}({expr}) = {deriv}")
+
+    if "integrate" in operations:
+        integral = integrate(expr, var)
+        results["integral"] = {"expr": integral, "latex": latex(integral)}
+        print(f"∫{expr} d{var} = {integral}")
+
+    if "series" in operations:
+        ser = series(expr, var, 0, n=6)
+        results["series"] = {"expr": ser, "latex": latex(ser)}
+        print(f"Taylor series: {ser}")
+
+    if "limit" in operations:
+        from sympy import limit as sp_limit
+        lim = sp_limit(expr, var, oo)
+        results["limit"] = {"expr": lim, "latex": latex(lim)}
+        print(f"lim({var}→∞) {expr} = {lim}")
+
+    return results
+```
+
+## 3. 線形代数 (記号的)
+
+```python
+def symbolic_linear_algebra(matrix_data):
+    """
+    記号的線形代数 — 固有値・固有ベクトル・行列分解。
+
+    Parameters:
+        matrix_data: list of lists — 行列要素 (記号含む)
+    """
+    M = Matrix(matrix_data)
+    print(f"Matrix ({M.rows}×{M.cols}):")
+    sp.pprint(M)
+
+    results = {}
+
+    # Determinant
+    det = M.det()
+    results["determinant"] = {"expr": det, "latex": latex(det)}
+    print(f"\nDeterminant: {det}")
+
+    # Eigenvalues & eigenvectors
+    eigenvals = M.eigenvals()
+    results["eigenvalues"] = {str(k): v for k, v in eigenvals.items()}
+    print(f"Eigenvalues: {eigenvals}")
+
+    eigenvects = M.eigenvects()
+    results["eigenvectors"] = [
+        {"eigenvalue": str(ev[0]), "multiplicity": ev[1],
+         "vectors": [str(v) for v in ev[2]]}
+        for ev in eigenvects
+    ]
+
+    # Characteristic polynomial
+    lam = symbols("lambda")
+    char_poly = M.charpoly(lam)
+    results["characteristic_polynomial"] = {
+        "expr": str(char_poly.as_expr()),
+        "latex": latex(char_poly.as_expr()),
+    }
+    print(f"Characteristic polynomial: {char_poly.as_expr()}")
+
+    # Inverse (if nonsingular)
+    if det != 0:
+        inv = M.inv()
+        results["inverse"] = {"latex": latex(inv)}
+        print(f"Inverse exists: {M.rows}×{M.cols}")
+
+    return results
+```
+
+## 4. 科学モデリング (薬物動態学 PK モデル例)
+
+```python
+def pk_compartment_model(n_compartments=1):
+    """
+    薬物動態学コンパートメントモデルの記号的解法。
+
+    Parameters:
+        n_compartments: int — 1 (1-compartment) or 2 (2-compartment)
+    """
+    t = symbols("t", positive=True)
+
+    if n_compartments == 1:
+        # 1-compartment: dC/dt = -ke * C
+        C = Function("C")
+        ke, C0 = symbols("k_e C_0", positive=True)
+        ode = Eq(C(t).diff(t), -ke * C(t))
+        solution = dsolve(ode, C(t), ics={C(0): C0})
+
+        # Half-life
+        t_half = sp.solve(Eq(solution.rhs, C0/2), t)[0]
+
+        # AUC (0→∞)
+        auc = integrate(solution.rhs, (t, 0, oo))
+
+        result = {
+            "model": "1-compartment IV bolus",
+            "ode": latex(ode),
+            "solution": latex(solution),
+            "half_life": latex(t_half),
+            "auc_inf": latex(auc),
+        }
+        print(f"PK 1-compartment: C(t) = {solution.rhs}")
+        print(f"  t½ = {t_half}")
+        print(f"  AUC(0→∞) = {auc}")
+
+    elif n_compartments == 2:
+        # 2-compartment model
+        C1, C2 = Function("C1"), Function("C2")
+        k10, k12, k21, D, V1 = symbols("k_10 k_12 k_21 D V_1", positive=True)
+
+        ode1 = Eq(C1(t).diff(t), -(k10 + k12)*C1(t) + k21*C2(t))
+        ode2 = Eq(C2(t).diff(t), k12*C1(t) - k21*C2(t))
+
+        system = [ode1, ode2]
+        solution = sp.dsolve(system, [C1(t), C2(t)])
+
+        result = {
+            "model": "2-compartment IV bolus",
+            "system": [latex(eq) for eq in system],
+            "solution": [latex(sol) for sol in solution],
+        }
+        print(f"PK 2-compartment system defined")
+        for sol in solution:
+            print(f"  {sol}")
+
+    return result
+```
+
+## 5. LaTeX 数式エクスポート
+
+```python
+def export_equations_latex(equations, output_file="equations.tex"):
+    """
+    記号数式を LaTeX ファイルにエクスポート。
+
+    Parameters:
+        equations: dict — {name: sympy_expr}
+        output_file: str — 出力 LaTeX パス
+    """
+    lines = [
+        r"\documentclass{article}",
+        r"\usepackage{amsmath,amssymb}",
+        r"\begin{document}",
+        "",
+    ]
+
+    for name, expr in equations.items():
+        lines.append(f"% {name}")
+        lines.append(r"\begin{equation}")
+        lines.append(f"  {latex(expr)}")
+        lines.append(r"\end{equation}")
+        lines.append("")
+
+    lines.append(r"\end{document}")
+
+    with open(output_file, "w") as f:
+        f.write("\n".join(lines))
+
+    print(f"LaTeX exported: {output_file} ({len(equations)} equations)")
+    return output_file
+```
+
+---
+
+## パイプライン出力
+
+| 出力ファイル | 説明 | 連携先スキル |
+|---|---|---|
+| `results/symbolic_solutions.json` | 記号解 (LaTeX 形式) | → latex-formatter, academic-writing |
+| `results/ode_solutions.json` | ODE 解析解 | → systems-biology, admet-pharmacokinetics |
+| `equations.tex` | LaTeX 数式集 | → latex-formatter |
+| `figures/symbolic_plot.png` | 記号解の可視化 | → publication-figures |
+
+## パイプライン統合
+
+```
+systems-biology ──→ symbolic-mathematics ──→ latex-formatter
+  (SBML/ODE)         (SymPy 解析解)         (LaTeX 変換)
+                           │
+                           ├──→ admet-pharmacokinetics (PK モデル)
+                           ├──→ bayesian-statistics (尤度導出)
+                           └──→ computational-materials (バンド理論)
+```