@nahisaho/satori 0.1.0

package/src/.github/skills/scientific-sequence-analysis/SKILL.md

@@ -0,0 +1,389 @@
+---
+name: scientific-sequence-analysis
+description: |
+  ゲノム配列解析スキル。コドン使用頻度（RSCU/CAI）、ペアワイズアラインメント
+  （Needleman-Wunsch/Smith-Waterman）、系統解析（Jukes-Cantor/UPGMA/ブートストラップ）、
+  ORF 探索、CpG 島検出、制限酵素マッピング、タンパク質特性（pI/GRAVY/疎水性プロファイル）
+  の解析テンプレート。Scientific Skills Exp-09 で確立したパターン。
+---
+
+# Scientific Sequence Analysis
+
+DNA / RNA / タンパク質の配列解析パイプライン。bioinformatics スキルが scRNA-seq や
+バルク RNA-seq のオミクスレベル解析を扱うのに対し、本スキルは個々の配列レベル
+（分子生物学レベル）の解析に特化する。
+
+## When to Use
+
+- DNA / タンパク質配列の特性解析が必要なとき
+- コドン使用頻度・バイアスを分析するとき
+- ペアワイズ/マルチプルアラインメント、系統樹を作成するとき
+- ORF 探索、CpG 島検出、制限酵素マッピングが必要なとき
+
+---
+
+## Quick Start
+
+## 1. 塩基組成解析
+
+```python
+from collections import Counter
+import numpy as np
+import pandas as pd
+
+def sequence_composition(sequence, seq_type="dna"):
+    """
+    配列の塩基/アミノ酸組成を算出する。
+
+    Returns:
+        dict with counts, frequencies, GC content (DNA), MW estimate
+    """
+    seq = sequence.upper()
+    counts = Counter(seq)
+    total = len(seq)
+    freq = {k: v / total * 100 for k, v in counts.items()}
+
+    result = {"length": total, "composition": counts, "frequency_pct": freq}
+
+    if seq_type == "dna":
+        gc = (counts.get("G", 0) + counts.get("C", 0)) / total * 100
+        at = (counts.get("A", 0) + counts.get("T", 0)) / total * 100
+        result["gc_content_pct"] = gc
+        result["at_content_pct"] = at
+    elif seq_type == "rna":
+        gc = (counts.get("G", 0) + counts.get("C", 0)) / total * 100
+        result["gc_content_pct"] = gc
+
+    return result
+```
+
+## 2. コドン使用頻度（RSCU / CAI）
+
+```python
+from Bio.Data import CodonTable
+
+CODON_TABLE = {
+    "TTT": "F", "TTC": "F", "TTA": "L", "TTG": "L",
+    "CTT": "L", "CTC": "L", "CTA": "L", "CTG": "L",
+    "ATT": "I", "ATC": "I", "ATA": "I", "ATG": "M",
+    "GTT": "V", "GTC": "V", "GTA": "V", "GTG": "V",
+    "TCT": "S", "TCC": "S", "TCA": "S", "TCG": "S",
+    "CCT": "P", "CCC": "P", "CCA": "P", "CCG": "P",
+    "ACT": "T", "ACC": "T", "ACA": "T", "ACG": "T",
+    "GCT": "A", "GCC": "A", "GCA": "A", "GCG": "A",
+    "TAT": "Y", "TAC": "Y", "TAA": "*", "TAG": "*",
+    "CAT": "H", "CAC": "H", "CAA": "Q", "CAG": "Q",
+    "AAT": "N", "AAC": "N", "AAA": "K", "AAG": "K",
+    "GAT": "D", "GAC": "D", "GAA": "E", "GAG": "E",
+    "TGT": "C", "TGC": "C", "TGA": "*", "TGG": "W",
+    "CGT": "R", "CGC": "R", "CGA": "R", "CGG": "R",
+    "AGT": "S", "AGC": "S", "AGA": "R", "AGG": "R",
+    "GGT": "G", "GGC": "G", "GGA": "G", "GGG": "G",
+}
+
+def compute_rscu(cds_sequence):
+    """
+    Relative Synonymous Codon Usage (RSCU) を算出する。
+
+    RSCU = observed / expected
+    expected = total for AA / number of synonymous codons
+    RSCU = 1: 均等使用, >1: 優先使用, <1: 劣位使用
+    """
+    seq = cds_sequence.upper().replace("U", "T")
+    codons = [seq[i:i+3] for i in range(0, len(seq)-2, 3)]
+    codon_counts = Counter(codons)
+
+    # アミノ酸ごとの同義コドン集計
+    aa_groups = {}
+    for codon, aa in CODON_TABLE.items():
+        if aa == "*":
+            continue
+        aa_groups.setdefault(aa, []).append(codon)
+
+    rscu = {}
+    for aa, synonymous in aa_groups.items():
+        total = sum(codon_counts.get(c, 0) for c in synonymous)
+        n_syn = len(synonymous)
+        for codon in synonymous:
+            observed = codon_counts.get(codon, 0)
+            expected = total / n_syn if n_syn > 0 else 0
+            rscu[codon] = observed / expected if expected > 0 else 0
+
+    return rscu
+
+
+def codon_adaptation_index(cds_sequence, reference_rscu):
+    """
+    Codon Adaptation Index (CAI) を算出する。
+
+    CAI = exp(1/L * Σ ln(w_i))
+    w_i = RSCU_i / RSCU_max (for synonymous family)
+    """
+    seq = cds_sequence.upper().replace("U", "T")
+    codons = [seq[i:i+3] for i in range(0, len(seq)-2, 3)]
+
+    # 各同義ファミリーの最大 RSCU
+    aa_groups = {}
+    for codon, aa in CODON_TABLE.items():
+        if aa == "*":
+            continue
+        aa_groups.setdefault(aa, []).append(codon)
+
+    max_rscu = {}
+    for aa, synonymous in aa_groups.items():
+        max_val = max(reference_rscu.get(c, 0) for c in synonymous)
+        for c in synonymous:
+            max_rscu[c] = max_val
+
+    w_values = []
+    for codon in codons:
+        if codon in CODON_TABLE and CODON_TABLE[codon] != "*":
+            w = reference_rscu.get(codon, 0) / max_rscu.get(codon, 1)
+            if w > 0:
+                w_values.append(np.log(w))
+
+    cai = np.exp(np.mean(w_values)) if w_values else 0
+    return cai
+```
+
+## 3. ペアワイズアラインメント
+
+```python
+def needleman_wunsch(seq1, seq2, match=2, mismatch=-1, gap=-2):
+    """
+    Needleman-Wunsch グローバルアラインメント（動的計画法）。
+
+    Returns:
+        aligned_seq1, aligned_seq2, score
+    """
+    n, m = len(seq1), len(seq2)
+    dp = np.zeros((n+1, m+1))
+    traceback = np.zeros((n+1, m+1), dtype=int)  # 0=diag, 1=up, 2=left
+
+    for i in range(1, n+1):
+        dp[i][0] = i * gap
+    for j in range(1, m+1):
+        dp[0][j] = j * gap
+
+    for i in range(1, n+1):
+        for j in range(1, m+1):
+            s = match if seq1[i-1] == seq2[j-1] else mismatch
+            scores = [dp[i-1][j-1] + s, dp[i-1][j] + gap, dp[i][j-1] + gap]
+            dp[i][j] = max(scores)
+            traceback[i][j] = np.argmax(scores)
+
+    # トレースバック
+    a1, a2 = [], []
+    i, j = n, m
+    while i > 0 or j > 0:
+        if i > 0 and j > 0 and traceback[i][j] == 0:
+            a1.append(seq1[i-1]); a2.append(seq2[j-1]); i -= 1; j -= 1
+        elif i > 0 and traceback[i][j] == 1:
+            a1.append(seq1[i-1]); a2.append("-"); i -= 1
+        else:
+            a1.append("-"); a2.append(seq2[j-1]); j -= 1
+
+    return "".join(reversed(a1)), "".join(reversed(a2)), dp[n][m]
+```
+
+## 4. 系統解析
+
+```python
+def jukes_cantor_distance(seq1, seq2):
+    """Jukes-Cantor 距離: d = -3/4 ln(1 - 4p/3)"""
+    aligned_len = min(len(seq1), len(seq2))
+    mismatches = sum(1 for a, b in zip(seq1[:aligned_len], seq2[:aligned_len])
+                     if a != b and a != "-" and b != "-")
+    valid = sum(1 for a, b in zip(seq1[:aligned_len], seq2[:aligned_len])
+                if a != "-" and b != "-")
+    p = mismatches / valid if valid > 0 else 0
+
+    if p >= 0.75:
+        return float("inf")
+    return -0.75 * np.log(1 - 4 * p / 3)
+
+
+def upgma_tree(distance_matrix, names):
+    """
+    UPGMA (Unweighted Pair Group Method with Arithmetic Mean) 系統樹を構築する。
+
+    Returns:
+        Newick 形式の文字列
+    """
+    n = len(names)
+    dm = distance_matrix.copy()
+    clusters = {i: names[i] for i in range(n)}
+    sizes = {i: 1 for i in range(n)}
+
+    while len(clusters) > 1:
+        keys = list(clusters.keys())
+        min_dist = float("inf")
+        merge_i, merge_j = 0, 0
+
+        for a in range(len(keys)):
+            for b in range(a+1, len(keys)):
+                if dm[keys[a]][keys[b]] < min_dist:
+                    min_dist = dm[keys[a]][keys[b]]
+                    merge_i, merge_j = keys[a], keys[b]
+
+        height = min_dist / 2
+        new_name = f"({clusters[merge_i]}:{height:.4f},{clusters[merge_j]}:{height:.4f})"
+
+        new_id = max(clusters.keys()) + 1
+        clusters[new_id] = new_name
+        sizes[new_id] = sizes[merge_i] + sizes[merge_j]
+
+        # 新ノードへの距離更新（加重平均）
+        new_row = {}
+        for k in clusters.keys():
+            if k != new_id:
+                d = (sizes[merge_i] * dm[merge_i].get(k, 0) +
+                     sizes[merge_j] * dm[merge_j].get(k, 0)) / sizes[new_id]
+                new_row[k] = d
+
+        dm[new_id] = new_row
+        for k in new_row:
+            dm.setdefault(k, {})[new_id] = new_row[k]
+
+        del clusters[merge_i]
+        del clusters[merge_j]
+
+    return list(clusters.values())[0] + ";"
+```
+
+## 5. ORF 探索
+
+```python
+def find_orfs(sequence, min_length_aa=100):
+    """
+    全6リーディングフレームからORF（Open Reading Frame）を探索する。
+
+    Returns:
+        list of dict with frame, start, end, length_aa, protein_seq
+    """
+    seq = sequence.upper()
+    reverse_comp = seq.translate(str.maketrans("ATGC", "TACG"))[::-1]
+
+    orfs = []
+    for strand, s in [("+", seq), ("-", reverse_comp)]:
+        for frame in range(3):
+            i = frame
+            while i < len(s) - 2:
+                codon = s[i:i+3]
+                if codon == "ATG":
+                    # ORF 開始 → 停止コドンまでスキャン
+                    protein = []
+                    j = i
+                    while j < len(s) - 2:
+                        c = s[j:j+3]
+                        aa = CODON_TABLE.get(c, "X")
+                        if aa == "*":
+                            break
+                        protein.append(aa)
+                        j += 3
+                    if len(protein) >= min_length_aa:
+                        orfs.append({
+                            "strand": strand,
+                            "frame": frame + 1,
+                            "start": i + 1,
+                            "end": j + 3,
+                            "length_aa": len(protein),
+                            "protein_seq": "".join(protein[:50]) + "...",
+                        })
+                    i = j + 3
+                else:
+                    i += 3
+
+    return sorted(orfs, key=lambda x: x["length_aa"], reverse=True)
+```
+
+## 6. CpG 島検出
+
+```python
+def detect_cpg_islands(sequence, window=200, step=1,
+                        min_gc=0.50, min_obs_exp=0.60, min_length=200):
+    """
+    配列中の CpG island を検出する。
+
+    判定基準（Gardiner-Garden & Frommer, 1987）:
+    - GC含量 ≥ 50%
+    - CpG observed/expected ≥ 0.60
+    - 長さ ≥ 200 bp
+    """
+    seq = sequence.upper()
+    islands = []
+    in_island = False
+    start = 0
+
+    for i in range(0, len(seq) - window, step):
+        w = seq[i:i+window]
+        gc = (w.count("G") + w.count("C")) / window
+        cpg_obs = w.count("CG") / window
+        c_freq = w.count("C") / window
+        g_freq = w.count("G") / window
+        cpg_exp = c_freq * g_freq
+        obs_exp = cpg_obs / cpg_exp if cpg_exp > 0 else 0
+
+        if gc >= min_gc and obs_exp >= min_obs_exp:
+            if not in_island:
+                start = i
+                in_island = True
+        else:
+            if in_island:
+                length = i - start + window
+                if length >= min_length:
+                    islands.append({"start": start+1, "end": i+window,
+                                   "length": length})
+                in_island = False
+
+    return islands
+```
+
+## 7. タンパク質特性
+
+```python
+AMINO_ACID_MW = {
+    "A": 89.09, "R": 174.20, "N": 132.12, "D": 133.10, "C": 121.16,
+    "E": 147.13, "Q": 146.15, "G": 75.03, "H": 155.16, "I": 131.17,
+    "L": 131.17, "K": 146.19, "M": 149.21, "F": 165.19, "P": 115.13,
+    "S": 105.09, "T": 119.12, "W": 204.23, "Y": 181.19, "V": 117.15,
+}
+
+KYTE_DOOLITTLE = {
+    "A": 1.8, "R": -4.5, "N": -3.5, "D": -3.5, "C": 2.5,
+    "E": -3.5, "Q": -3.5, "G": -0.4, "H": -3.2, "I": 4.5,
+    "L": 3.8, "K": -3.9, "M": 1.9, "F": 2.8, "P": -1.6,
+    "S": -0.8, "T": -0.7, "W": -0.9, "Y": -1.3, "V": 4.2,
+}
+
+def protein_properties(protein_seq):
+    """タンパク質の物理化学的特性を算出する。"""
+    seq = protein_seq.upper()
+    mw = sum(AMINO_ACID_MW.get(aa, 0) for aa in seq) - 18.015 * (len(seq) - 1)
+    gravy = np.mean([KYTE_DOOLITTLE.get(aa, 0) for aa in seq])
+
+    return {
+        "length_aa": len(seq),
+        "molecular_weight_Da": mw,
+        "gravy": gravy,
+        "hydrophobic_pct": sum(1 for aa in seq if KYTE_DOOLITTLE.get(aa, 0) > 0) / len(seq) * 100,
+    }
+```
+
+## References
+
+### Output Files
+
+| ファイル | 形式 |
+|---|---|
+| `results/sequence_composition.csv` | CSV |
+| `results/rscu_analysis.csv` | CSV |
+| `results/orf_predictions.csv` | CSV |
+| `results/cpg_islands.csv` | CSV |
+| `figures/codon_usage_heatmap.png` | PNG |
+| `figures/phylogenetic_tree.png` | PNG |
+| `figures/hydrophobicity_profile.png` | PNG |
+
+#### 参照実験
+
+- **Exp-09**: コドン使用頻度、ペアワイズアラインメント、系統解析、ORF 探索、CpG 島検出

package/src/.github/skills/scientific-spectral-signal/SKILL.md

@@ -0,0 +1,227 @@
+---
+name: scientific-spectral-signal
+description: |
+  分光スペクトルおよび生体信号の前処理・解析スキル。ベースライン補正、フィルタリング、
+  ピーク検出、帯域パワー解析を行う際に使用。
+  Scientific Skills Exp-08（ECG/EEG）、Exp-11（ラマン分光）で確立したパターン。
+---
+
+# Scientific Spectral & Signal Processing
+
+分光スペクトル（ラマン、IR、UV-Vis など）および生体信号（ECG, EEG）の
+前処理・解析パイプラインスキル。ノイズ除去、ベースライン補正、ピーク検出、
+周波数解析の標準ワークフローを提供する。
+
+## When to Use
+
+- スペクトルデータの前処理（ベースライン補正、平滑化、正規化）
+- 時系列信号のフィルタリング（バンドパス、ノッチ）
+- ピーク検出と定量化
+- 周波数帯域パワー解析（EEG δ/θ/α/β/γ）
+- スペクトル類似度解析と分類
+
+## Quick Start
+
+## スペクトル前処理パイプライン
+
+### 1. ALS ベースライン補正（Exp-11）
+
+```python
+import numpy as np
+from scipy import sparse
+from scipy.sparse.linalg import spsolve
+
+def baseline_correction_als(y, lam=1e5, p=0.01, niter=10):
+    """
+    Asymmetric Least Squares (ALS) によるベースライン推定。
+    蛍光バックグラウンドの除去に使用。
+    lam: 平滑化パラメータ（大きいほど滑らか）
+    p: 非対称性パラメータ（小さいほどベースライン追従が強い）
+    """
+    L = len(y)
+    D = sparse.diags([1, -2, 1], [0, -1, -2], shape=(L, L - 2))
+    w = np.ones(L)
+    for _ in range(niter):
+        W = sparse.diags(w)
+        Z = W + lam * D.dot(D.transpose())
+        z = spsolve(Z, w * y)
+        w = p * (y > z) + (1 - p) * (y < z)
+    return z
+
+def remove_baseline(spectrum, wavenumbers, lam=1e5, p=0.01):
+    """ベースライン補正済みスペクトルを返す。"""
+    baseline = baseline_correction_als(spectrum, lam=lam, p=p)
+    return spectrum - baseline
+```
+
+### 2. Savitzky-Golay 平滑化
+
+```python
+from scipy.signal import savgol_filter
+
+def smooth_spectrum(spectrum, window_length=11, polyorder=3):
+    """Savitzky-Golay フィルタでスペクトルを平滑化する。"""
+    return savgol_filter(spectrum, window_length=window_length, polyorder=polyorder)
+```
+
+### 3. 正規化
+
+```python
+def normalize_spectrum(spectrum, method="minmax"):
+    """
+    スペクトルを正規化する。
+    method: 'minmax', 'snv' (Standard Normal Variate), 'area'
+    """
+    if method == "minmax":
+        return (spectrum - spectrum.min()) / (spectrum.max() - spectrum.min() + 1e-10)
+    elif method == "snv":
+        return (spectrum - spectrum.mean()) / (spectrum.std() + 1e-10)
+    elif method == "area":
+        return spectrum / (np.trapz(np.abs(spectrum)) + 1e-10)
+    else:
+        raise ValueError(f"Unknown method: {method}")
+```
+
+### 4. ピーク検出
+
+```python
+from scipy.signal import find_peaks
+
+def detect_peaks(spectrum, wavenumbers=None, height=None,
+                 prominence=0.05, distance=10, width=None):
+    """
+    スペクトル中のピークを検出する。
+    返値: ピーク位置インデックス、ピーク属性辞書
+    """
+    peaks, properties = find_peaks(
+        spectrum, height=height, prominence=prominence,
+        distance=distance, width=width
+    )
+
+    if wavenumbers is not None:
+        peak_positions = wavenumbers[peaks]
+    else:
+        peak_positions = peaks
+
+    return peaks, peak_positions, properties
+```
+
+## 生体信号処理パイプライン
+
+### 5. バンドパス/ノッチフィルタ（Exp-08）
+
+```python
+from scipy.signal import butter, sosfilt, iirnotch
+
+def bandpass_filter(signal, fs, lowcut, highcut, order=4):
+    """Butterworth バンドパスフィルタ。"""
+    nyq = 0.5 * fs
+    sos = butter(order, [lowcut / nyq, highcut / nyq], btype="band", output="sos")
+    return sosfilt(sos, signal)
+
+def notch_filter(signal, fs, freq=50.0, Q=30.0):
+    """商用電源ノイズ除去用ノッチフィルタ（50/60 Hz）。"""
+    b, a = iirnotch(freq, Q, fs)
+    from scipy.signal import filtfilt
+    return filtfilt(b, a, signal)
+```
+
+### 6. 周波数帯域パワー解析（EEG）
+
+```python
+from scipy.signal import welch
+
+EEG_BANDS = {
+    "delta": (0.5, 4),
+    "theta": (4, 8),
+    "alpha": (8, 13),
+    "beta":  (13, 30),
+    "gamma": (30, 100),
+}
+
+def band_power(signal, fs, band, method="welch"):
+    """指定周波数帯域のパワーを算出する。"""
+    freqs, psd = welch(signal, fs=fs, nperseg=min(len(signal), 256))
+    low, high = band
+    idx = np.logical_and(freqs >= low, freqs <= high)
+    return np.trapz(psd[idx], freqs[idx])
+
+def eeg_band_powers(signal, fs, bands=None):
+    """EEG の全帯域パワーを一括計算する。"""
+    if bands is None:
+        bands = EEG_BANDS
+    powers = {}
+    for name, (low, high) in bands.items():
+        powers[name] = band_power(signal, fs, (low, high))
+    total = sum(powers.values())
+    relative = {k: v / total for k, v in powers.items()}
+    return powers, relative
+```
+
+### 7. R 波検出 & HRV 解析（ECG）
+
+```python
+def detect_r_peaks(ecg_signal, fs, height_factor=0.5, distance_ms=300):
+    """ECG 信号から R 波を検出する。"""
+    min_distance = int(distance_ms * fs / 1000)
+    threshold = height_factor * np.max(ecg_signal)
+    peaks, _ = find_peaks(ecg_signal, height=threshold, distance=min_distance)
+    return peaks
+
+def hrv_analysis(r_peaks, fs):
+    """R-R 間隔から HRV 指標を算出する。"""
+    rr_intervals = np.diff(r_peaks) / fs * 1000  # ms
+    return {
+        "mean_RR": np.mean(rr_intervals),
+        "SDNN": np.std(rr_intervals, ddof=1),
+        "RMSSD": np.sqrt(np.mean(np.diff(rr_intervals) ** 2)),
+        "pNN50": np.sum(np.abs(np.diff(rr_intervals)) > 50) / len(rr_intervals) * 100,
+        "mean_HR": 60000 / np.mean(rr_intervals),
+    }
+```
+
+### 8. スペクトル類似度解析（Exp-11）
+
+```python
+from scipy.spatial.distance import cosine
+from scipy.cluster.hierarchy import linkage, dendrogram
+from scipy.spatial.distance import squareform
+
+def spectral_similarity_matrix(spectra_dict, method="cosine"):
+    """
+    スペクトル間の類似度行列を算出する。
+    spectra_dict: {name: spectrum_array}
+    """
+    names = list(spectra_dict.keys())
+    n = len(names)
+    sim_matrix = np.zeros((n, n))
+
+    for i in range(n):
+        for j in range(n):
+            if method == "cosine":
+                sim_matrix[i, j] = 1 - cosine(spectra_dict[names[i]],
+                                               spectra_dict[names[j]])
+            elif method == "pearson":
+                sim_matrix[i, j] = np.corrcoef(spectra_dict[names[i]],
+                                                spectra_dict[names[j]])[0, 1]
+
+    return pd.DataFrame(sim_matrix, index=names, columns=names)
+```
+
+## References
+
+### Output Files
+
+| ファイル | 形式 |
+|---|---|
+| `results/peak_detection_results.csv` | CSV |
+| `results/hrv_metrics.csv` | CSV |
+| `results/spectral_similarity.csv` | CSV |
+| `figures/spectrum_processed.png` | PNG |
+| `figures/peak_detection.png` | PNG |
+| `figures/eeg_band_powers.png` | PNG |
+
+#### 参照実験
+
+- **Exp-08**: ECG/EEG 生体信号処理（フィルタ、R 波検出、HRV、帯域パワー）
+- **Exp-11**: ラマン分光（ALS ベースライン、ピーク検出、類似度行列、クラスタリング）