@pikaa-ai/pikaa 0.2.5 → 0.3.1

package/skills/pyopenms/scripts/consensus_to_matrix.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+Consensus Map to Quantification Matrix
+
+Convert a consensusXML into analysis-ready tables: a wide intensity matrix
+(consensus features x samples) joined with feature metadata (RT, m/z, charge,
+quality), plus an optional long/tidy format. Optionally normalize intensities
+across samples (median or quantile).
+
+Usage:
+    python consensus_to_matrix.py study.consensusXML --out quant.csv
+    python consensus_to_matrix.py study.consensusXML --out quant.csv --normalize median
+    python consensus_to_matrix.py study.consensusXML --out quant.csv --long long.csv
+"""
+
+import argparse
+import os
+import sys
+
+try:
+    import pyopenms as ms
+except ImportError:
+    print("Error: pyopenms not installed. Install with: uv pip install pyopenms")
+    sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Export a consensusXML to a quant matrix CSV.")
+    parser.add_argument("input", help="Input consensusXML")
+    parser.add_argument("--out", required=True, help="Output wide-matrix CSV")
+    parser.add_argument("--long", help="Also write a tidy/long-format CSV")
+    parser.add_argument("--normalize", choices=["median", "quantile", "none"], default="none",
+                        help="Cross-sample intensity normalization (default none)")
+    args = parser.parse_args()
+
+    if not os.path.exists(args.input):
+        print(f"Error: file not found: {args.input}")
+        sys.exit(1)
+
+    cm = ms.ConsensusMap()
+    ms.ConsensusXMLFile().load(args.input, cm)
+    print(f"Loaded {cm.size()} consensus features, {len(cm.getColumnHeaders())} samples")
+
+    if args.normalize == "median":
+        ms.ConsensusMapNormalizerAlgorithmMedian().normalizeMaps(
+            cm, ms.NormalizationMethod.NM_SCALE, "", "")
+        print("Applied median normalization")
+    elif args.normalize == "quantile":
+        ms.ConsensusMapNormalizerAlgorithmQuantile().normalizeMaps(cm)
+        print("Applied quantile normalization")
+
+    import pandas as pd
+    # Ensure unique row identity; consensus ids may be 0/duplicated on some maps.
+    cm.setUniqueIds()
+    intensity_df = cm.get_intensity_df().reset_index(drop=True)
+    meta_df = cm.get_metadata_df().reset_index(drop=True)
+    matrix = pd.concat([meta_df, intensity_df], axis=1)
+    matrix.to_csv(args.out, index_label="consensus_id")
+    print(f"Wrote {args.out} ({matrix.shape[0]} features x {intensity_df.shape[1]} samples)")
+
+    if args.long:
+        long_df = intensity_df.copy()
+        long_df.insert(0, "consensus_id", range(len(long_df)))
+        long_df = long_df.melt(id_vars="consensus_id", var_name="sample", value_name="intensity")
+        long_df.to_csv(args.long, index=False)
+        print(f"Wrote {args.long} ({len(long_df)} rows)")
+
+
+if __name__ == "__main__":
+    main()

package/skills/pyopenms/scripts/convert_format.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""
+Convert Between MS File Formats
+
+Convert spectral data between mzML, mzXML, and MGF, with optional MS-level and
+RT/intensity filtering. Uses FileHandler for transparent format detection on load.
+
+Supported conversions (by output extension): .mzML, .mzXML, .mgf
+
+Usage:
+    python convert_format.py input.mzXML output.mzML
+    python convert_format.py input.mzML peaks.mgf --ms-level 2
+    python convert_format.py input.mzML out.mzML --rt-min 60 --rt-max 600 --min-intensity 500
+"""
+
+import argparse
+import os
+import sys
+
+try:
+    import pyopenms as ms
+except ImportError:
+    print("Error: pyopenms not installed. Install with: uv pip install pyopenms")
+    sys.exit(1)
+
+
+def load_experiment(path):
+    exp = ms.MSExperiment()
+    ms.FileHandler().loadExperiment(path, exp)
+    return exp
+
+
+def filter_experiment(exp, ms_level=None, rt_min=None, rt_max=None, min_intensity=None):
+    out = ms.MSExperiment()
+    for spec in exp:
+        if ms_level is not None and spec.getMSLevel() != ms_level:
+            continue
+        rt = spec.getRT()
+        if rt_min is not None and rt < rt_min:
+            continue
+        if rt_max is not None and rt > rt_max:
+            continue
+        if min_intensity is not None:
+            mz, inten = spec.get_peaks()
+            keep = inten >= min_intensity
+            spec.set_peaks((mz[keep], inten[keep]))
+        out.addSpectrum(spec)
+    # carry chromatograms if no MS-level filter requested
+    if ms_level is None:
+        for chrom in exp.getChromatograms():
+            out.addChromatogram(chrom)
+    return out
+
+
+def store_experiment(exp, path):
+    ext = path.lower()
+    if ext.endswith(".mzml"):
+        ms.MzMLFile().store(path, exp)
+    elif ext.endswith(".mzxml"):
+        ms.MzXMLFile().store(path, exp)
+    elif ext.endswith(".mgf"):
+        ms.MascotGenericFile().store(path, exp)
+    else:
+        raise ValueError(f"Unsupported output extension: {path} (use .mzML, .mzXML, or .mgf)")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert/filter MS files between formats.")
+    parser.add_argument("input", help="Input file (mzML/mzXML/...)")
+    parser.add_argument("output", help="Output file (.mzML, .mzXML, or .mgf)")
+    parser.add_argument("--ms-level", type=int, help="Keep only spectra at this MS level")
+    parser.add_argument("--rt-min", type=float, help="Minimum retention time (s)")
+    parser.add_argument("--rt-max", type=float, help="Maximum retention time (s)")
+    parser.add_argument("--min-intensity", type=float, help="Drop peaks below this intensity")
+    args = parser.parse_args()
+
+    if not os.path.exists(args.input):
+        print(f"Error: file not found: {args.input}")
+        sys.exit(1)
+
+    print(f"Loading {args.input}...")
+    exp = load_experiment(args.input)
+    print(f"  {exp.getNrSpectra()} spectra, {exp.getNrChromatograms()} chromatograms")
+
+    if any(v is not None for v in (args.ms_level, args.rt_min, args.rt_max, args.min_intensity)):
+        exp = filter_experiment(exp, args.ms_level, args.rt_min, args.rt_max, args.min_intensity)
+        print(f"  after filtering: {exp.getNrSpectra()} spectra")
+
+    print(f"Writing {args.output}...")
+    store_experiment(exp, args.output)
+    print("Done.")
+
+
+if __name__ == "__main__":
+    main()

package/skills/pyopenms/scripts/detect_adducts.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""
+Adduct Detection / Feature Decharging
+
+Group features that are different ionization forms (adducts/charge variants) of
+the same neutral compound using MetaboliteFeatureDeconvolution. Annotates each
+feature with its inferred adduct and neutral mass, and writes the decharged
+feature map plus a consensus map of grouped adduct families.
+
+Adducts use OpenMS deconvolution syntax 'Elements:Charge:Probability', where
+the charge is given as '+'/'-' signs (e.g. 'Ca:++:0.5' is +2) and losses are
+written like 'H-2O-1'. Example: 'H:+:0.4'. This differs from the bracket
+notation (e.g. [M+H]+) used elsewhere.
+
+Usage:
+    python detect_adducts.py features.featureXML --out-features decharged.featureXML
+    python detect_adducts.py features.featureXML --negative
+    python detect_adducts.py features.featureXML --adducts "H:+:0.6,Na:+:0.2,K:+:0.2"
+"""
+
+import argparse
+import os
+import sys
+
+try:
+    import pyopenms as ms
+except ImportError:
+    print("Error: pyopenms not installed. Install with: uv pip install pyopenms")
+    sys.exit(1)
+
+# 'Elements:Charge:Probability' (OpenMS deconvolution syntax)
+DEFAULT_POS = "H:+:0.4,Na:+:0.25,NH4:+:0.25,K:+:0.1,H-2O-1:0:0.05"
+DEFAULT_NEG = "H-1:-:0.6,Cl:-:0.2,H-3O-1:-:0.1,CH2O2H-1:-:0.1"
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Detect adducts / decharge a feature map.")
+    parser.add_argument("input", help="Input featureXML")
+    parser.add_argument("--out-features", help="Output decharged featureXML (default: <input>_decharged.featureXML)")
+    parser.add_argument("--out-consensus", help="Optional consensusXML of adduct groups")
+    parser.add_argument("--negative", action="store_true", help="Negative ionization mode")
+    parser.add_argument("--adducts", help="Comma-separated potential adducts (overrides defaults)")
+    parser.add_argument("--charge-min", type=int, default=1)
+    parser.add_argument("--charge-max", type=int, default=1)
+    parser.add_argument("--mass-max-diff", type=float, default=0.05, help="Max mass difference (Da)")
+    parser.add_argument("--rt-max-diff", type=float, default=10.0, help="Max RT difference (s)")
+    args = parser.parse_args()
+
+    if not os.path.exists(args.input):
+        print(f"Error: file not found: {args.input}")
+        sys.exit(1)
+
+    fm = ms.FeatureMap()
+    ms.FeatureXMLFile().load(args.input, fm)
+    print(f"Loaded {fm.size()} features")
+
+    adducts = args.adducts
+    if adducts is None:
+        adducts = DEFAULT_NEG if args.negative else DEFAULT_POS
+
+    mfd = ms.MetaboliteFeatureDeconvolution()
+    p = mfd.getDefaults()
+    p.setValue("potential_adducts", [a.strip().encode() for a in adducts.split(",")])
+    p.setValue("charge_min", args.charge_min)
+    p.setValue("charge_max", args.charge_max)
+    p.setValue("mass_max_diff", args.mass_max_diff)
+    p.setValue("retention_max_diff", args.rt_max_diff)
+    p.setValue("negative_mode", "true" if args.negative else "false")
+    mfd.setParameters(p)
+
+    fm_out = ms.FeatureMap()
+    groups = ms.ConsensusMap()
+    edges = ms.ConsensusMap()
+    mfd.compute(fm, fm_out, groups, edges)
+
+    annotated = sum(1 for f in fm_out if f.metaValueExists("dc_charge_adducts"))
+    print(f"Decharged feature map: {fm_out.size()} features ({annotated} adduct-annotated)")
+    print(f"Adduct groups: {groups.size()}")
+
+    out_features = args.out_features or os.path.splitext(args.input)[0] + "_decharged.featureXML"
+    ms.FeatureXMLFile().store(out_features, fm_out)
+    print(f"Wrote {out_features}")
+
+    if args.out_consensus:
+        ms.ConsensusXMLFile().store(args.out_consensus, groups)
+        print(f"Wrote {args.out_consensus}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/pyopenms/scripts/detect_features_centroided.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+Peptide/Centroided Feature Detection
+
+Detect features in centroided (peak-picked) LC-MS data using
+FeatureFinderAlgorithmPicked -- the modern replacement for the removed
+FeatureFinderCentroided. Suited to peptide/proteomics data with defined
+isotope patterns and charge states.
+
+Outputs a featureXML and optionally a CSV table.
+
+Usage:
+    python detect_features_centroided.py centroided.mzML
+    python detect_features_centroided.py data.mzML --out-csv feats.csv --charge-low 2 --charge-high 5
+"""
+
+import argparse
+import os
+import sys
+
+try:
+    import pyopenms as ms
+except ImportError:
+    print("Error: pyopenms not installed. Install with: uv pip install pyopenms")
+    sys.exit(1)
+
+
+def detect_features(exp, mz_tol_ppm=10.0, charge_low=1, charge_high=4, min_spectra=7):
+    exp.sortSpectra(True)
+    exp.updateRanges()
+    ff = ms.FeatureFinderAlgorithmPicked()
+    params = ff.getDefaults()
+    params.setValue("mass_trace:mz_tolerance", mz_tol_ppm / 1e6 * 400.0)  # approx Da at m/z 400
+    params.setValue("mass_trace:min_spectra", int(min_spectra))
+    params.setValue("isotopic_pattern:charge_low", int(charge_low))
+    params.setValue("isotopic_pattern:charge_high", int(charge_high))
+    ff.setParameters(params)
+
+    features = ms.FeatureMap()
+    seeds = ms.FeatureMap()
+    ff.run(exp, features, params, seeds)
+    features.setUniqueIds()
+    return features
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Centroided/peptide feature detection.")
+    parser.add_argument("input", help="Centroided mzML file")
+    parser.add_argument("--out-features", help="Output featureXML (default: <input>.featureXML)")
+    parser.add_argument("--out-csv", help="Optional CSV table of features")
+    parser.add_argument("--mz-tol-ppm", type=float, default=10.0, help="m/z tolerance in ppm (default 10)")
+    parser.add_argument("--charge-low", type=int, default=1, help="Lower charge bound (default 1)")
+    parser.add_argument("--charge-high", type=int, default=4, help="Upper charge bound (default 4)")
+    parser.add_argument("--min-spectra", type=int, default=7, help="Min scans per feature (default 7)")
+    args = parser.parse_args()
+
+    if not os.path.exists(args.input):
+        print(f"Error: file not found: {args.input}")
+        sys.exit(1)
+
+    exp = ms.MSExperiment()
+    ms.FileHandler().loadExperiment(args.input, exp)
+    print(f"Loaded {exp.getNrSpectra()} spectra from {args.input}")
+
+    fm = detect_features(exp, mz_tol_ppm=args.mz_tol_ppm, charge_low=args.charge_low,
+                         charge_high=args.charge_high, min_spectra=args.min_spectra)
+    print(f"Features detected: {fm.size()}")
+
+    out_features = args.out_features or os.path.splitext(args.input)[0] + ".featureXML"
+    ms.FeatureXMLFile().store(out_features, fm)
+    print(f"Wrote {out_features}")
+
+    if args.out_csv:
+        df = fm.get_df()
+        df.to_csv(args.out_csv, index=False)
+        print(f"Wrote {args.out_csv} ({len(df)} rows)")
+
+
+if __name__ == "__main__":
+    main()

package/skills/pyopenms/scripts/detect_features_metabo.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""
+Untargeted Metabolomics Feature Detection
+
+Run the standard OpenMS small-molecule feature-finding pipeline on centroided
+LC-MS data:
+
+    MassTraceDetection -> ElutionPeakDetection -> FeatureFindingMetabo
+
+Outputs a featureXML and (optionally) a CSV table of detected features.
+This is the recommended entry point for untargeted metabolomics preprocessing.
+
+Usage:
+    python detect_features_metabo.py sample.mzML
+    python detect_features_metabo.py sample.mzML --out-features feats.featureXML --out-csv feats.csv
+    python detect_features_metabo.py sample.mzML --ppm 5 --noise 5000 --charge-low 1 --charge-high 3
+"""
+
+import argparse
+import os
+import sys
+
+try:
+    import pyopenms as ms
+except ImportError:
+    print("Error: pyopenms not installed. Install with: uv pip install pyopenms")
+    sys.exit(1)
+
+
+def detect_features(exp, ppm=10.0, noise=1000.0, charge_low=1, charge_high=3,
+                    remove_single=True, iso_model="metabolites (5% RMS)"):
+    """Run MTD -> EPD -> FFM. Returns a FeatureMap."""
+    exp.sortSpectra(True)
+
+    # 1. Mass trace detection
+    mtd = ms.MassTraceDetection()
+    p = mtd.getDefaults()
+    p.setValue("mass_error_ppm", float(ppm))
+    p.setValue("noise_threshold_int", float(noise))
+    mtd.setParameters(p)
+    mass_traces = []
+    mtd.run(exp, mass_traces, 0)
+
+    # 2. Elution peak detection
+    epd = ms.ElutionPeakDetection()
+    p = epd.getDefaults()
+    p.setValue("width_filtering", "fixed")
+    epd.setParameters(p)
+    mt_split = []
+    epd.detectPeaks(mass_traces, mt_split)
+
+    # 3. Feature assembly (isotope/charge resolution)
+    ffm = ms.FeatureFindingMetabo()
+    p = ffm.getDefaults()
+    p.setValue("isotope_filtering_model", iso_model)
+    p.setValue("remove_single_traces", "true" if remove_single else "false")
+    p.setValue("charge_lower_bound", int(charge_low))
+    p.setValue("charge_upper_bound", int(charge_high))
+    p.setValue("report_convex_hulls", "true")
+    ffm.setParameters(p)
+    fm = ms.FeatureMap()
+    chrom_out = []
+    ffm.run(mt_split, fm, chrom_out)
+    fm.setUniqueIds()
+    return fm, len(mass_traces)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Untargeted metabolomics feature detection.")
+    parser.add_argument("input", help="Centroided mzML file")
+    parser.add_argument("--out-features", help="Output featureXML (default: <input>.featureXML)")
+    parser.add_argument("--out-csv", help="Optional CSV table of features")
+    parser.add_argument("--ppm", type=float, default=10.0, help="Mass trace m/z tolerance in ppm (default 10)")
+    parser.add_argument("--noise", type=float, default=1000.0, help="Noise intensity threshold (default 1000)")
+    parser.add_argument("--charge-low", type=int, default=1, help="Lower charge bound (default 1)")
+    parser.add_argument("--charge-high", type=int, default=3, help="Upper charge bound (default 3)")
+    parser.add_argument("--keep-singletons", action="store_true",
+                        help="Keep single-trace features (default: remove)")
+    parser.add_argument("--iso-model", default="metabolites (5% RMS)",
+                        help="Isotope filtering model (e.g. 'none', 'metabolites (5%% RMS)')")
+    args = parser.parse_args()
+
+    if not os.path.exists(args.input):
+        print(f"Error: file not found: {args.input}")
+        sys.exit(1)
+
+    exp = ms.MSExperiment()
+    ms.FileHandler().loadExperiment(args.input, exp)
+    print(f"Loaded {exp.getNrSpectra()} spectra from {args.input}")
+
+    fm, n_traces = detect_features(
+        exp, ppm=args.ppm, noise=args.noise,
+        charge_low=args.charge_low, charge_high=args.charge_high,
+        remove_single=not args.keep_singletons, iso_model=args.iso_model,
+    )
+    print(f"Mass traces: {n_traces}")
+    print(f"Features detected: {fm.size()}")
+
+    out_features = args.out_features or os.path.splitext(args.input)[0] + ".featureXML"
+    ms.FeatureXMLFile().store(out_features, fm)
+    print(f"Wrote {out_features}")
+
+    if args.out_csv:
+        df = fm.get_df()
+        df.to_csv(args.out_csv, index=False)
+        print(f"Wrote {args.out_csv} ({len(df)} rows)")
+
+
+if __name__ == "__main__":
+    main()

package/skills/pyopenms/scripts/digest_protein.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+In-Silico Protein Digestion
+
+Digest protein sequences (FASTA or a single sequence) with a configurable
+protease, producing theoretical peptides with masses and m/z. Useful for
+targeted method design and search-space estimation.
+
+Usage:
+    python digest_protein.py proteins.fasta --out peptides.csv
+    python digest_protein.py --sequence MKWVTFISLLLLFSSAYS --enzyme Trypsin --missed 2
+    python digest_protein.py proteins.fasta --min-length 7 --max-length 40 --charges 1 2 3
+"""
+
+import argparse
+import os
+import sys
+
+try:
+    import pyopenms as ms
+except ImportError:
+    print("Error: pyopenms not installed. Install with: uv pip install pyopenms")
+    sys.exit(1)
+
+PROTON = 1.0072764665789
+
+
+def read_fasta(path):
+    entries = []
+    fe = ms.FASTAFile()
+    seqs = []
+    fe.load(path, seqs)
+    for s in seqs:
+        entries.append((s.identifier, s.sequence))
+    return entries
+
+
+def digest(seq_str, enzyme, missed, min_len, max_len):
+    dig = ms.ProteaseDigestion()
+    dig.setEnzyme(enzyme)
+    dig.setMissedCleavages(missed)
+    out = []
+    dig.digest(ms.AASequence.fromString(seq_str), out, min_len, max_len)
+    return out
+
+
+def main():
+    parser = argparse.ArgumentParser(description="In-silico protein digestion.")
+    parser.add_argument("fasta", nargs="?", help="FASTA file (optional if --sequence given)")
+    parser.add_argument("--sequence", help="Single protein sequence")
+    parser.add_argument("--enzyme", default="Trypsin", help="Protease (default Trypsin)")
+    parser.add_argument("--missed", type=int, default=2, help="Max missed cleavages (default 2)")
+    parser.add_argument("--min-length", type=int, default=6, help="Min peptide length (default 6)")
+    parser.add_argument("--max-length", type=int, default=40, help="Max peptide length (default 40)")
+    parser.add_argument("--charges", type=int, nargs="+", default=[1, 2], help="m/z charge states")
+    parser.add_argument("--out", help="Output CSV of peptides")
+    args = parser.parse_args()
+
+    proteins = []
+    if args.fasta:
+        if not os.path.exists(args.fasta):
+            print(f"Error: file not found: {args.fasta}")
+            sys.exit(1)
+        proteins = read_fasta(args.fasta)
+    elif args.sequence:
+        proteins = [("input", args.sequence)]
+    else:
+        parser.error("provide a FASTA file or --sequence")
+
+    rows = []
+    seen = set()
+    for prot_id, seq in proteins:
+        for pep in digest(seq, args.enzyme, args.missed, args.min_length, args.max_length):
+            pep_str = pep.toString()
+            key = (prot_id, pep_str)
+            if key in seen:
+                continue
+            seen.add(key)
+            mono = pep.getMonoWeight()
+            row = {"protein": prot_id, "peptide": pep_str, "length": pep.size(),
+                   "mono_mass": round(mono, 5)}
+            for z in args.charges:
+                row[f"mz_z{z}"] = round((mono + z * PROTON) / z, 5)
+            rows.append(row)
+
+    print(f"Proteins: {len(proteins)}  Unique peptides: {len(rows)}")
+    for r in rows[:10]:
+        print(f"  {r['peptide']}  ({r['length']} aa, {r['mono_mass']} Da)")
+    if len(rows) > 10:
+        print(f"  ... and {len(rows) - 10} more")
+
+    if args.out:
+        import csv
+        with open(args.out, "w", newline="") as fh:
+            w = csv.DictWriter(fh, fieldnames=list(rows[0].keys()) if rows else ["protein", "peptide"])
+            w.writeheader()
+            w.writerows(rows)
+        print(f"Wrote {args.out}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/pyopenms/scripts/export_gnps_sirius.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""
+Export for GNPS (FBMN) and SIRIUS
+
+Generate the input files required by downstream annotation tools:
+
+    gnps    Feature-Based Molecular Networking: writes an MGF of MS2 spectra
+            (from a consensusXML linked across samples) plus the GNPS
+            quantification table.
+    sirius  Writes a SIRIUS .ms file (and compound-info TSV) from mzML +
+            featureXML input for formula/structure elucidation.
+
+Usage:
+    python export_gnps_sirius.py gnps study.consensusXML --mzml s1.mzML s2.mzML --out-prefix gnps_out
+    python export_gnps_sirius.py sirius sample.mzML --featurexml sample.featureXML --out sample.ms
+"""
+
+import argparse
+import os
+import sys
+
+try:
+    import pyopenms as ms
+except ImportError:
+    print("Error: pyopenms not installed. Install with: uv pip install pyopenms")
+    sys.exit(1)
+
+
+def export_gnps(args):
+    cm = ms.ConsensusMap()
+    ms.ConsensusXMLFile().load(args.consensus, cm)
+    print(f"Loaded {cm.size()} consensus features")
+
+    mgf_out = f"{args.out_prefix}.mgf"
+    quant_out = f"{args.out_prefix}_quant.txt"
+
+    mzml_paths = [p.encode() for p in args.mzml]
+    ms.GNPSMGFFile().store(args.consensus.encode(), mzml_paths, mgf_out)
+    print(f"Wrote {mgf_out}")
+
+    ms.GNPSQuantificationFile().store(cm, quant_out)
+    print(f"Wrote {quant_out}")
+    print("Upload both to GNPS Feature-Based Molecular Networking.")
+
+
+def export_sirius(args):
+    out_ms = args.out or os.path.splitext(args.input)[0] + ".ms"
+    out_info = args.compound_info or os.path.splitext(out_ms)[0] + "_compounds.tsv"
+
+    exporter = ms.SiriusExportAlgorithm()
+    feature_files = [args.featurexml.encode()] if args.featurexml else []
+    try:
+        exporter.run([args.input.encode()], feature_files, out_ms, out_info)
+    except RuntimeError as e:
+        if "SourceFile" in str(e):
+            print("Error: the mzML lacks proper SourceFile annotation required by SIRIUS export.")
+            print("This is normal for synthetic/hand-built mzML. Re-export the file through")
+            print("OpenMS FileConverter (or any real instrument export) so it carries source")
+            print("metadata, then retry. Vendor-converted mzML files already satisfy this.")
+            sys.exit(2)
+        raise
+    print(f"Wrote {out_ms}")
+    print(f"Wrote {out_info}")
+    print("Run SIRIUS on the .ms file for formula/structure elucidation.")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Export for GNPS FBMN or SIRIUS.")
+    sub = parser.add_subparsers(dest="mode", required=True)
+
+    g = sub.add_parser("gnps", help="Export GNPS FBMN inputs")
+    g.add_argument("consensus", help="consensusXML linked across samples")
+    g.add_argument("--mzml", nargs="+", required=True, help="Source mzML files (with MS2)")
+    g.add_argument("--out-prefix", default="gnps_export", help="Output prefix")
+
+    s = sub.add_parser("sirius", help="Export SIRIUS .ms file")
+    s.add_argument("input", help="mzML file (with MS2)")
+    s.add_argument("--featurexml", help="Optional featureXML to group spectra")
+    s.add_argument("--out", help="Output .ms path")
+    s.add_argument("--compound-info", help="Output compound-info TSV path")
+
+    args = parser.parse_args()
+    if args.mode == "gnps":
+        export_gnps(args)
+    else:
+        export_sirius(args)
+
+
+if __name__ == "__main__":
+    main()