@bgicli/bgicli 2.1.0 → 2.2.0

package/data/skills/bio-comparative-genomics-ancestral-reconstruction/SKILL.md

@@ -0,0 +1,312 @@
+<!--
+# COPYRIGHT NOTICE
+# This file is part of the "Universal Biomedical Skills" project.
+# Copyright (c) 2026 MD BABU MIA, PhD <md.babu.mia@mssm.edu>
+# All Rights Reserved.
+#
+# This code is proprietary and confidential.
+# Unauthorized copying of this file, via any medium is strictly prohibited.
+#
+# Provenance: Authenticated by MD BABU MIA
+
+-->
+
+---
+name: bio-comparative-genomics-ancestral-reconstruction
+description: Reconstruct ancestral sequences at phylogenetic nodes using PAML and IQ-TREE marginal likelihood methods. Infer ancient protein sequences and trace evolutionary trajectories through sequence history. Use when inferring ancestral states for protein resurrection or tracing evolutionary history.
+tool_type: mixed
+primary_tool: PAML
+measurable_outcome: Execute skill workflow successfully with valid output within 15 minutes.
+allowed-tools:
+  - read_file
+  - run_shell_command
+---
+
+# Ancestral Sequence Reconstruction
+
+## PAML Ancestral Reconstruction
+
+```python
+'''Ancestral sequence reconstruction with PAML codeml/baseml'''
+
+import subprocess
+import re
+from Bio import SeqIO
+from Bio.Seq import Seq
+
+
+def create_asr_control(alignment, tree, output_dir, seq_type='protein'):
+    '''Create control file for ancestral reconstruction
+
+    RateAncestor = 1: Enable ancestral reconstruction
+    Generates RST file with ancestral sequences
+
+    For codons: Use codeml with seqtype = 1
+    For amino acids: Use codeml with seqtype = 2
+    For nucleotides: Use baseml
+    '''
+    if seq_type == 'protein':
+        ctl = f'''
+      seqfile = {alignment}
+     treefile = {tree}
+      outfile = {output_dir}/asr.mlc
+
+      seqtype = 2
+        model = 3
+    aaRatefile = wag.dat
+
+ RateAncestor = 1
+    cleandata = 0
+        '''
+    else:  # codon
+        ctl = f'''
+      seqfile = {alignment}
+     treefile = {tree}
+      outfile = {output_dir}/asr.mlc
+
+      seqtype = 1
+    CodonFreq = 2
+        model = 0
+      NSsites = 0
+
+ RateAncestor = 1
+    cleandata = 0
+        '''
+
+    ctl_file = f'{output_dir}/asr.ctl'
+    with open(ctl_file, 'w') as f:
+        f.write(ctl)
+
+    return ctl_file
+
+
+def parse_rst_file(rst_file):
+    '''Parse PAML RST file for ancestral sequences
+
+    RST contains:
+    - Tree with node numbers
+    - Ancestral sequences at each node
+    - Posterior probabilities for each site
+
+    Node numbering: Extant sequences first, then internal nodes
+    '''
+    ancestors = {}
+    current_node = None
+    current_seq = []
+
+    with open(rst_file) as f:
+        content = f.read()
+
+    # Find ancestral sequence section
+    if 'Ancestral reconstruction by' in content:
+        sections = content.split('Ancestral reconstruction by')
+        for section in sections[1:]:
+            lines = section.strip().split('\n')
+            for line in lines:
+                if line.startswith('node #'):
+                    if current_node and current_seq:
+                        ancestors[current_node] = ''.join(current_seq)
+                    match = re.search(r'node #(\d+)', line)
+                    if match:
+                        current_node = f'Node_{match.group(1)}'
+                        current_seq = []
+                elif current_node and line.strip() and not line.startswith(' '):
+                    # Sequence line
+                    seq_part = ''.join(line.split()[1:]) if len(line.split()) > 1 else ''
+                    current_seq.append(seq_part)
+
+    if current_node and current_seq:
+        ancestors[current_node] = ''.join(current_seq)
+
+    return ancestors
+
+
+def extract_marginal_probabilities(rst_file):
+    '''Extract site-wise posterior probabilities
+
+    High confidence: P > 0.95 (commonly used threshold)
+    Moderate confidence: P > 0.80
+    Low confidence: P < 0.80 (consider alternatives)
+
+    Report ambiguous sites for experimental validation
+    '''
+    site_probs = []
+
+    with open(rst_file) as f:
+        in_probs = False
+        for line in f:
+            if 'Prob of best state' in line:
+                in_probs = True
+                continue
+            if in_probs and line.strip():
+                parts = line.split()
+                if len(parts) >= 3:
+                    try:
+                        site = int(parts[0])
+                        state = parts[1]
+                        prob = float(parts[2])
+                        site_probs.append({
+                            'site': site,
+                            'state': state,
+                            'probability': prob,
+                            'confidence': 'high' if prob > 0.95 else 'moderate' if prob > 0.8 else 'low'
+                        })
+                    except ValueError:
+                        in_probs = False
+
+    return site_probs
+```
+
+## IQ-TREE Ancestral Reconstruction
+
+```python
+def run_iqtree_asr(alignment, tree=None, model='LG+G4', output_prefix='asr'):
+    '''Run IQ-TREE for ancestral sequence reconstruction
+
+    IQ-TREE provides:
+    - Marginal reconstruction (default)
+    - Joint reconstruction (-asr-joint)
+    - State file (.state) with probabilities
+
+    Advantages over PAML:
+    - Automatic model selection
+    - Better handling of gaps
+    - Faster for large datasets
+    '''
+    cmd = f'iqtree2 -s {alignment} -m {model} --ancestral -pre {output_prefix}'
+
+    if tree:
+        cmd += f' -te {tree}'
+
+    subprocess.run(cmd, shell=True)
+
+    return f'{output_prefix}.state'
+
+
+def parse_iqtree_state(state_file):
+    '''Parse IQ-TREE .state file
+
+    Format: Node  Site  State  Probability  [other states and probs]
+    '''
+    ancestors = {}
+
+    with open(state_file) as f:
+        next(f)  # Skip header
+        for line in f:
+            parts = line.strip().split('\t')
+            if len(parts) >= 4:
+                node = parts[0]
+                site = int(parts[1])
+                state = parts[2]
+                prob = float(parts[3])
+
+                if node not in ancestors:
+                    ancestors[node] = {'sequence': [], 'probabilities': []}
+                ancestors[node]['sequence'].append(state)
+                ancestors[node]['probabilities'].append(prob)
+
+    # Convert to sequences
+    for node in ancestors:
+        ancestors[node]['sequence'] = ''.join(ancestors[node]['sequence'])
+
+    return ancestors
+```
+
+## Alternative State Analysis
+
+```python
+def get_alternative_states(site_probs, threshold=0.1):
+    '''Identify sites with plausible alternative ancestral states
+
+    Alternative states with P > 0.1 should be considered
+    for experimental validation (ancestral protein resurrection)
+
+    These sites may:
+    - Affect function differently
+    - Represent true ancestral ambiguity
+    - Be targets for directed evolution
+    '''
+    ambiguous_sites = []
+
+    for site_data in site_probs:
+        if 'alternatives' in site_data:
+            significant_alts = [
+                alt for alt in site_data['alternatives']
+                if alt['probability'] > threshold
+            ]
+            if significant_alts:
+                ambiguous_sites.append({
+                    'site': site_data['site'],
+                    'best_state': site_data['state'],
+                    'best_prob': site_data['probability'],
+                    'alternatives': significant_alts
+                })
+
+    return ambiguous_sites
+
+
+def calculate_sequence_confidence(site_probs):
+    '''Calculate overall confidence in ancestral sequence
+
+    Metrics:
+    - Mean posterior probability
+    - Fraction of high-confidence sites (P > 0.95)
+    - Number of ambiguous positions
+    '''
+    if not site_probs:
+        return None
+
+    probs = [s['probability'] for s in site_probs]
+    high_conf = sum(1 for p in probs if p > 0.95) / len(probs)
+    low_conf = sum(1 for p in probs if p < 0.8)
+
+    return {
+        'mean_probability': sum(probs) / len(probs),
+        'high_confidence_fraction': high_conf,
+        'low_confidence_sites': low_conf,
+        'total_sites': len(probs),
+        'overall_quality': 'high' if high_conf > 0.9 else 'moderate' if high_conf > 0.7 else 'low'
+    }
+```
+
+## Ancestral Protein Resurrection
+
+```python
+def design_asr_construct(ancestral_seq, extant_reference, ambiguous_sites):
+    '''Design constructs for ancestral protein resurrection
+
+    Strategy:
+    1. Use most probable state at each position
+    2. Create alternative constructs at ambiguous sites
+    3. Consider codon optimization for expression host
+
+    Validation:
+    - Test activity of resurrected proteins
+    - Compare to extant proteins
+    - Test alternative constructs at ambiguous positions
+    '''
+    constructs = [{'name': 'ASR_ML', 'sequence': ancestral_seq, 'description': 'Maximum likelihood ancestral'}]
+
+    # Create alternative constructs for ambiguous sites
+    for site in ambiguous_sites[:5]:  # Limit to top 5 ambiguous
+        alt_seq = list(ancestral_seq)
+        best_alt = site['alternatives'][0]
+        alt_seq[site['site'] - 1] = best_alt['state']
+        constructs.append({
+            'name': f"ASR_alt_{site['site']}",
+            'sequence': ''.join(alt_seq),
+            'description': f"Alternative at position {site['site']}: {best_alt['state']}"
+        })
+
+    return constructs
+```
+
+## Related Skills
+
+- comparative-genomics/positive-selection - Selection analysis on ancestral branches
+- comparative-genomics/ortholog-inference - Identify orthologs for reconstruction
+- phylogenetics/modern-tree-inference - Generate trees for ASR
+- alignment/pairwise-alignment - Prepare MSA for reconstruction
+
+
+<!-- AUTHOR_SIGNATURE: 9a7f3c2e-MD-BABU-MIA-2026-MSSM-SECURE -->

package/data/skills/bio-comparative-genomics-hgt-detection/SKILL.md

@@ -0,0 +1,341 @@
+<!--
+# COPYRIGHT NOTICE
+# This file is part of the "Universal Biomedical Skills" project.
+# Copyright (c) 2026 MD BABU MIA, PhD <md.babu.mia@mssm.edu>
+# All Rights Reserved.
+#
+# This code is proprietary and confidential.
+# Unauthorized copying of this file, via any medium is strictly prohibited.
+#
+# Provenance: Authenticated by MD BABU MIA
+
+-->
+
+---
+name: bio-comparative-genomics-hgt-detection
+description: Detect horizontal gene transfer events using HGTector, compositional analysis, and phylogenetic incongruence methods. Identify foreign genes in bacterial and archaeal genomes from anomalous composition or unexpected phylogenetic placement. Use when searching for horizontally transferred genes or analyzing genome evolution in prokaryotes.
+tool_type: mixed
+primary_tool: HGTector
+measurable_outcome: Execute skill workflow successfully with valid output within 15 minutes.
+allowed-tools:
+  - read_file
+  - run_shell_command
+---
+
+# Horizontal Gene Transfer Detection
+
+## HGTector Workflow
+
+```python
+'''HGT detection with HGTector and compositional methods'''
+
+import subprocess
+import pandas as pd
+import numpy as np
+from Bio import SeqIO
+from collections import Counter
+
+
+def run_hgtector(proteome, taxonomy_db, output_dir, threads=4):
+    '''Run HGTector for HGT detection
+
+    HGTector uses BLAST-based phyletic distribution analysis:
+    1. BLAST proteome against reference database
+    2. Classify genes by taxonomic distribution
+    3. Identify genes with unexpected phyletic patterns
+
+    Requires:
+    - NCBI taxonomy database
+    - Reference protein database (e.g., RefSeq)
+    '''
+    # Search against database
+    search_cmd = f'''hgtector search \\
+        -i {proteome} \\
+        -o {output_dir}/search \\
+        -m diamond \\
+        -t {threads} \\
+        -d refseq'''
+
+    subprocess.run(search_cmd, shell=True)
+
+    # Analyze results
+    analyze_cmd = f'''hgtector analyze \\
+        -i {output_dir}/search \\
+        -o {output_dir}/analyze \\
+        -t {taxonomy_db}'''
+
+    subprocess.run(analyze_cmd, shell=True)
+
+    return f'{output_dir}/analyze'
+
+
+def parse_hgtector_results(results_dir):
+    '''Parse HGTector output for HGT candidates
+
+    Output columns:
+    - gene: Gene identifier
+    - close: Score for close taxonomic matches
+    - distal: Score for distal taxonomic matches
+    - hgt: HGT prediction (1 = putative HGT)
+    '''
+    results_file = f'{results_dir}/scores.tsv'
+    df = pd.read_csv(results_file, sep='\t')
+
+    # Classify HGT candidates
+    # distal > close suggests foreign origin
+    df['hgt_score'] = df['distal'] - df['close']
+
+    # Threshold: Higher positive score = stronger HGT signal
+    # Score > 0.5: Moderate HGT evidence
+    # Score > 1.0: Strong HGT evidence
+    df['hgt_call'] = df['hgt_score'] > 0.5
+
+    return df
+```
+
+## Compositional Analysis
+
+```python
+def calculate_gc_content(sequence):
+    '''Calculate GC content of a sequence'''
+    gc = sum(1 for nt in sequence.upper() if nt in 'GC')
+    return gc / len(sequence) if sequence else 0
+
+
+def calculate_codon_usage(cds_sequence):
+    '''Calculate codon usage frequencies
+
+    Foreign genes often have different codon usage
+    reflecting their donor genome's bias
+    '''
+    if len(cds_sequence) % 3 != 0:
+        return None
+
+    codons = [cds_sequence[i:i+3] for i in range(0, len(cds_sequence) - 2, 3)]
+    counts = Counter(codons)
+    total = sum(counts.values())
+
+    return {codon: count / total for codon, count in counts.items()}
+
+
+def calculate_cai(gene_codons, reference_codons):
+    '''Calculate Codon Adaptation Index
+
+    CAI measures how well a gene matches the host codon usage
+    Low CAI suggests foreign origin
+
+    CAI < 0.5: Potentially foreign
+    CAI 0.5-0.7: Intermediate
+    CAI > 0.7: Native-like codon usage
+    '''
+    import math
+
+    w_values = {}
+    for aa_codons in group_synonymous_codons(reference_codons):
+        max_freq = max(reference_codons.get(c, 0) for c in aa_codons)
+        if max_freq > 0:
+            for c in aa_codons:
+                w_values[c] = reference_codons.get(c, 0) / max_freq
+
+    cai_sum = 0
+    n = 0
+    for codon, freq in gene_codons.items():
+        if codon in w_values and w_values[codon] > 0:
+            cai_sum += math.log(w_values[codon]) * freq
+            n += freq
+
+    return math.exp(cai_sum) if n > 0 else 0
+
+
+def group_synonymous_codons(codon_usage):
+    '''Group codons by amino acid'''
+    genetic_code = {
+        'F': ['TTT', 'TTC'], 'L': ['TTA', 'TTG', 'CTT', 'CTC', 'CTA', 'CTG'],
+        'I': ['ATT', 'ATC', 'ATA'], 'M': ['ATG'], 'V': ['GTT', 'GTC', 'GTA', 'GTG'],
+        'S': ['TCT', 'TCC', 'TCA', 'TCG', 'AGT', 'AGC'],
+        'P': ['CCT', 'CCC', 'CCA', 'CCG'], 'T': ['ACT', 'ACC', 'ACA', 'ACG'],
+        'A': ['GCT', 'GCC', 'GCA', 'GCG'], 'Y': ['TAT', 'TAC'],
+        'H': ['CAT', 'CAC'], 'Q': ['CAA', 'CAG'], 'N': ['AAT', 'AAC'],
+        'K': ['AAA', 'AAG'], 'D': ['GAT', 'GAC'], 'E': ['GAA', 'GAG'],
+        'C': ['TGT', 'TGC'], 'W': ['TGG'], 'R': ['CGT', 'CGC', 'CGA', 'CGG', 'AGA', 'AGG'],
+        'G': ['GGT', 'GGC', 'GGA', 'GGG']
+    }
+    return [codons for codons in genetic_code.values()]
+
+
+def detect_gc_anomalies(genome_fasta, cds_gff, window_size=5000):
+    '''Detect regions with anomalous GC content
+
+    Horizontally transferred regions often have
+    different GC content than the host genome
+
+    Threshold: >2 standard deviations from genome mean
+    '''
+    # Load genome
+    genome = SeqIO.read(genome_fasta, 'fasta')
+    genome_gc = calculate_gc_content(str(genome.seq))
+
+    # Calculate windowed GC
+    windows = []
+    seq = str(genome.seq)
+    for i in range(0, len(seq) - window_size, window_size // 2):
+        window_seq = seq[i:i + window_size]
+        gc = calculate_gc_content(window_seq)
+        windows.append({
+            'start': i,
+            'end': i + window_size,
+            'gc': gc
+        })
+
+    df = pd.DataFrame(windows)
+
+    # Identify anomalies
+    mean_gc = df['gc'].mean()
+    std_gc = df['gc'].std()
+
+    # Z-score threshold: |Z| > 2 suggests anomalous region
+    df['z_score'] = (df['gc'] - mean_gc) / std_gc
+    df['anomalous'] = abs(df['z_score']) > 2
+
+    return df, genome_gc
+```
+
+## Phylogenetic Incongruence
+
+```python
+def detect_phylogenetic_incongruence(gene_tree, species_tree):
+    '''Detect HGT via phylogenetic incongruence
+
+    Compare gene tree topology to species tree
+    Genes with conflicting placement may be HGT
+
+    Methods:
+    - AU test: Approximately Unbiased test
+    - SH test: Shimodaira-Hasegawa test
+    - Bootstrap: Compare bootstrap support
+    '''
+    from Bio import Phylo
+    from io import StringIO
+
+    # Load trees
+    g_tree = Phylo.read(StringIO(gene_tree), 'newick')
+    s_tree = Phylo.read(StringIO(species_tree), 'newick')
+
+    # Get taxa
+    g_taxa = set(t.name for t in g_tree.get_terminals())
+    s_taxa = set(t.name for t in s_tree.get_terminals())
+
+    # Basic topological comparison
+    # For full analysis, use IQ-TREE topology tests
+    common_taxa = g_taxa & s_taxa
+
+    return {
+        'gene_taxa': g_taxa,
+        'species_taxa': s_taxa,
+        'common_taxa': common_taxa,
+        'unique_to_gene': g_taxa - s_taxa
+    }
+
+
+def run_topology_test(alignment, tree1, tree2, output_prefix):
+    '''Run AU/SH tests for tree comparison
+
+    Tests if gene significantly favors unexpected topology
+    p < 0.05 suggests trees are significantly different
+    '''
+    cmd = f'''iqtree2 -s {alignment} \\
+        -z trees.nwk \\
+        -n 0 \\
+        -zb 10000 \\
+        -au \\
+        -pre {output_prefix}'''
+
+    # Prepare tree file
+    with open('trees.nwk', 'w') as f:
+        f.write(f'{tree1}\n{tree2}\n')
+
+    subprocess.run(cmd, shell=True)
+
+    return f'{output_prefix}.iqtree'
+```
+
+## Genomic Island Detection
+
+```python
+def identify_genomic_islands(genome_gc, gene_annotations, gc_threshold=2):
+    '''Identify putative genomic islands (HGT clusters)
+
+    Genomic islands characteristics:
+    - Anomalous GC content
+    - Different codon usage
+    - Flanked by mobile elements (IS, integrases)
+    - Near tRNA genes (common integration sites)
+
+    Islands often contain:
+    - Pathogenicity factors
+    - Antibiotic resistance genes
+    - Metabolic capabilities
+    '''
+    # Group consecutive anomalous genes
+    islands = []
+    current_island = []
+
+    sorted_genes = sorted(gene_annotations, key=lambda x: x['start'])
+
+    for gene in sorted_genes:
+        if abs(gene.get('gc_zscore', 0)) > gc_threshold:
+            if not current_island:
+                current_island = [gene]
+            elif gene['start'] - current_island[-1]['end'] < 10000:
+                current_island.append(gene)
+            else:
+                if len(current_island) >= 3:  # Minimum 3 genes for island
+                    islands.append(current_island)
+                current_island = [gene]
+        else:
+            if current_island and len(current_island) >= 3:
+                islands.append(current_island)
+            current_island = []
+
+    if current_island and len(current_island) >= 3:
+        islands.append(current_island)
+
+    return islands
+
+
+def annotate_island_features(island_genes, mobile_element_db):
+    '''Annotate genomic island features
+
+    Look for:
+    - Integrases (island integration)
+    - Transposases (IS elements)
+    - Phage proteins
+    - tRNA genes nearby (integration hotspots)
+    '''
+    features = {
+        'has_integrase': False,
+        'has_transposase': False,
+        'has_phage': False,
+        'near_trna': False
+    }
+
+    for gene in island_genes:
+        product = gene.get('product', '').lower()
+        if 'integrase' in product:
+            features['has_integrase'] = True
+        if 'transposase' in product:
+            features['has_transposase'] = True
+        if 'phage' in product or 'prophage' in product:
+            features['has_phage'] = True
+
+    return features
+```
+
+## Related Skills
+
+- comparative-genomics/ortholog-inference - Identify orthologs for phylogenetic tests
+- phylogenetics/modern-tree-inference - Build gene trees for incongruence analysis
+- metagenomics/amr-detection - AMR genes often on mobile elements
+
+
+<!-- AUTHOR_SIGNATURE: 9a7f3c2e-MD-BABU-MIA-2026-MSSM-SECURE -->