Tooluniverse Metabolomics

# API Keys for ToolUniverse
# Copy this file to .env and fill in your actual API keys

BIOGRID_API_KEY=your_api_key_here

BOLTZ_MCP_SERVER_HOST=your_api_key_here

BRENDA_EMAIL=your_api_key_here

BRENDA_PASSWORD=your_api_key_here

DISGENET_API_KEY=your_api_key_here

EXPERT_FEEDBACK_MCP_SERVER_URL=your_api_key_here

NVIDIA_API_KEY=your_api_key_here

OMIM_API_KEY=your_api_key_here

TXAGENT_MCP_SERVER_HOST=your_api_key_here

USPTO_API_KEY=your_api_key_here

USPTO_MCP_SERVER_HOST=your_api_key_here

#!/usr/bin/env python3
"""
Diabetes Metabolomics Study Analysis
Tests the Metabolomics Research skill with a comprehensive diabetes research workflow
"""

from python_implementation import metabolomics_analysis_pipeline

if __name__ == "__main__":
    print("="*80)
    print("DIABETES METABOLOMICS RESEARCH ANALYSIS")
    print("="*80)
    print()
    print("This analysis will:")
    print("1. Identify and annotate diabetes-related metabolites")
    print("2. Retrieve details for study MTBLS1 (diabetes-related)")
    print("3. Search for additional diabetes studies")
    print("4. Generate a comprehensive research report")
    print()
    print("="*80)

    # Define metabolites involved in diabetes
    diabetes_metabolites = [
        "glucose",
        "lactate",
        "pyruvate",
        "citrate",
        "succinate"
    ]

    print(f"\nAnalyzing {len(diabetes_metabolites)} diabetes-related metabolites...")
    print(f"Metabolites: {', '.join(diabetes_metabolites)}")
    print(f"Study ID: MTBLS1")
    print(f"Search query: diabetes")
    print()

    # Run comprehensive analysis
    metabolomics_analysis_pipeline(
        metabolite_list=diabetes_metabolites,
        study_id="MTBLS1",
        search_query="diabetes",
        organism="Homo sapiens",
        output_file="diabetes_metabolomics_report.md"
    )

    print("\n" + "="*80)
    print("ANALYSIS COMPLETE!")
    print("="*80)
    print("\nReport saved to: diabetes_metabolomics_report.md")
    print("\nYou can now review:")
    print("  - HMDB annotations for all 5 metabolites")
    print("  - MTBLS1 study details")
    print("  - Related diabetes studies from MetaboLights")
    print("  - Database integration overview")
    print()

#!/usr/bin/env python3
"""
Metabolomics Research - Python SDK Implementation
Tested implementation following TDD principles
"""

from tooluniverse import ToolUniverse
from datetime import datetime
import json

def metabolomics_analysis_pipeline(
    metabolite_list=None,
    study_id=None,
    search_query=None,
    organism="Homo sapiens",
    output_file=None
):
    """
    Metabolomics research analysis pipeline.

    Args:
        metabolite_list: List of metabolite names (e.g., ["glucose", "lactate"])
        study_id: MetaboLights or Metabolomics Workbench study ID
        search_query: Keyword to search metabolomics studies
        organism: Organism name (default: "Homo sapiens")
        output_file: Output markdown file path (default: auto-generated)

    Returns:
        Path to generated report file
    """

    tu = ToolUniverse()
    tu.load_tools()

    # Generate output filename
    if output_file is None:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        if metabolite_list:
            output_file = f"metabolomics_metabolites_{timestamp}.md"
        elif study_id:
            output_file = f"metabolomics_{study_id}_{timestamp}.md"
        elif search_query:
            output_file = f"metabolomics_search_{search_query}_{timestamp}.md"
        else:
            output_file = f"metabolomics_analysis_{timestamp}.md"

    # Initialize report
    report = []
    report.append("# Metabolomics Research Analysis Report\n")
    report.append(f"**Generated**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")

    if metabolite_list:
        report.append(f"**Metabolites**: {', '.join(metabolite_list[:10])}{'...' if len(metabolite_list) > 10 else ''}\n")
    if study_id:
        report.append(f"**Study ID**: {study_id}\n")
    if search_query:
        report.append(f"**Search Query**: {search_query}\n")
    report.append(f"**Organism**: {organism}\n")

    report.append("\n---\n")

    # Phase 1: Metabolite Identification
    if metabolite_list and len(metabolite_list) > 0:
        report.append("\n## 1. Metabolite Identification & Annotation\n")

        for metabolite in metabolite_list[:10]:  # Limit to 10 for report length
            report.append(f"\n### Metabolite: {metabolite}\n")

            # HMDB Search
            try:
                result = tu.tools.HMDB_search(
                    operation="search",  # SOAP tool - CRITICAL
                    query=metabolite
                )

                if isinstance(result, dict) and result.get('status') == 'success':
                    data = result.get('data', {})  # FIX: data is dict, not list
                    results = data.get('results', [])  # FIX: results are nested

                    if results and len(results) > 0:
                        hmdb_entry = results[0]  # FIX: Access results array

                        # Use correct field names from actual API
                        report.append(f"**PubChem CID**: {hmdb_entry.get('cid', 'N/A')}\n")
                        report.append(f"**Name**: {hmdb_entry.get('name', 'N/A')}\n")
                        report.append(f"**Formula**: {hmdb_entry.get('formula', 'N/A')}\n")
                        report.append(f"**Molecular Weight**: {hmdb_entry.get('mw', 'N/A')}\n")

                        # Add HMDB search URL if available
                        hmdb_url = data.get('hmdb_search_url', '')
                        if hmdb_url:
                            report.append(f"**HMDB Search URL**: {hmdb_url}\n")
                    else:
                        report.append(f"*No results found for {metabolite}*\n")
                else:
                    report.append("*HMDB search unavailable.*\n")

            except Exception as e:
                report.append(f"*Error querying HMDB: {str(e)[:100]}*\n")

            # PubChem search (fallback)
            try:
                result = tu.tools.PubChem_get_CID_by_compound_name(name=metabolite)  # FIX: parameter is 'name', not 'compound_name'
                if isinstance(result, dict) and result.get('status') == 'success':
                    data = result.get('data', {})
                    cid = data.get('cid', 'N/A')
                    if cid != 'N/A':
                        report.append(f"**PubChem CID**: {cid}\n")

                        # Get properties
                        props = tu.tools.PubChem_get_compound_properties_by_CID(cid=cid)
                        if isinstance(props, dict) and props.get('status') == 'success':
                            prop_data = props.get('data', {})
                            report.append(f"**SMILES**: {prop_data.get('CanonicalSMILES', 'N/A')}\n")
            except Exception as e:
                pass  # PubChem fallback, don't report errors

    # Phase 2: Study Retrieval
    if study_id:
        report.append(f"\n## 2. Study Details: {study_id}\n")

        # Try MetaboLights first
        if study_id.startswith('MTBLS'):
            try:
                result = tu.tools.metabolights_get_study(study_id=study_id)
                if isinstance(result, dict) and result.get('status') == 'success':
                    data = result.get('data', {})
                    study = data.get('mtblsStudy', {})  # FIX: Extract nested study object

                    report.append(f"**Database**: MetaboLights\n")
                    # Use actual field names from API
                    report.append(f"**Study Status**: {study.get('studyStatus', 'N/A')}\n")
                    report.append(f"**Study ID**: {study.get('accession', 'N/A')}\n")
                    report.append(f"**Release Date**: {study.get('releaseDate', 'N/A')}\n")
                    report.append(f"**Modified Time**: {study.get('modifiedTime', 'N/A')}\n")
                    report.append(f"**HTTP URL**: {study.get('studyHttpUrl', 'N/A')}\n")
                else:
                    report.append("*Study details unavailable from MetaboLights.*\n")
            except Exception as e:
                report.append(f"*Error retrieving MetaboLights study: {str(e)[:100]}*\n")

        # Try Metabolomics Workbench
        elif study_id.startswith('ST'):
            try:
                result = tu.tools.MetabolomicsWorkbench_get_study(
                    study_id=study_id,
                    output_item="summary"
                )
                if isinstance(result, dict) and result.get('status') == 'success':
                    data = result.get('data', {})
                    # Parse the text response
                    if isinstance(data, str):
                        lines = data.strip().split('\n')
                        report.append(f"**Database**: Metabolomics Workbench\n")
                        for line in lines:
                            if '\t' in line:
                                key, value = line.split('\t', 1)
                                report.append(f"**{key}**: {value}\n")
                    else:
                        report.append(f"**Database**: Metabolomics Workbench\n")
                        report.append(f"**Data**: {data}\n")
                else:
                    report.append("*Study details unavailable from Metabolomics Workbench.*\n")
            except Exception as e:
                report.append(f"*Error retrieving Workbench study: {str(e)[:100]}*\n")

    # Phase 3: Study Search
    if search_query:
        report.append(f"\n## 3. Study Search: '{search_query}'\n")

        # MetaboLights search
        try:
            result = tu.tools.metabolights_search_studies(query=search_query)
            if isinstance(result, dict) and result.get('status') == 'success':
                data = result.get('data', [])
                if data:
                    report.append(f"\n### MetaboLights Studies ({len(data)} results)\n")
                    report.append("\n| Study ID | Preview |\n")
                    report.append("|----------|----------|\n")
                    for study in data[:15]:  # Limit to 15
                        if isinstance(study, str):
                            report.append(f"| {study} | - |\n")
                        elif isinstance(study, dict):
                            sid = study.get('accession', study.get('id', 'N/A'))
                            title = study.get('title', '')[:50]
                            report.append(f"| {sid} | {title} |\n")
                else:
                    report.append("\n*No MetaboLights studies found.*\n")
        except Exception as e:
            report.append(f"\n*Error searching MetaboLights: {str(e)[:100]}*\n")

    # Phase 4: Database Statistics (always included)
    report.append("\n## 4. Metabolomics Database Overview\n")

    try:
        result = tu.tools.metabolights_list_studies(size=10)
        if isinstance(result, dict) and result.get('status') == 'success':
            data = result.get('data', [])
            report.append(f"\n**MetaboLights**: {len(data)} studies available (sample)\n")
            report.append(f"**Recent studies**: {', '.join([s if isinstance(s, str) else s.get('accession', '') for s in data[:5]])}\n")
    except Exception:
        report.append("\n**MetaboLights**: Database available\n")

    report.append("\n**Databases integrated**:\n")
    report.append("- HMDB (Human Metabolome Database): 220,000+ metabolites\n")
    report.append("- MetaboLights: Public metabolomics repository\n")
    report.append("- Metabolomics Workbench: NIH metabolomics data\n")
    report.append("- PubChem: Chemical properties and bioactivity\n")

    # Write report to file
    report_content = ''.join(report)
    with open(output_file, 'w') as f:
        f.write(report_content)

    print(f"\n✅ Report generated: {output_file}")
    return output_file


if __name__ == "__main__":
    # Example usage
    print("Metabolomics Research Analysis - Python SDK Implementation")
    print("="*80)

    # Example 1: Metabolite list analysis
    print("\n[Example 1] Metabolite identification...")
    metabolomics_analysis_pipeline(
        metabolite_list=["glucose", "lactate", "pyruvate"],
        output_file="example1_metabolites.md"
    )

    # Example 2: Study retrieval
    print("\n[Example 2] Study analysis...")
    metabolomics_analysis_pipeline(
        study_id="MTBLS1",
        output_file="example2_study.md"
    )

    # Example 3: Study search
    print("\n[Example 3] Study search...")
    metabolomics_analysis_pipeline(
        search_query="diabetes",
        organism="Homo sapiens",
        output_file="example3_search.md"
    )

    print("\n✅ All examples completed!")

#!/usr/bin/env python3
"""Metabolism reference: pathways, isotope tracers, ATP yields."""
import argparse, json, sys

# --- 1. Central metabolism pathway data ---
PATHWAYS = {
    "glycolysis": {
        "name": "Glycolysis", "location": "cytoplasm",
        "input": "glucose", "output": "2 pyruvate",
        "net_atp": 2, "nadh": 2, "fadh2": 0, "gtp": 0, "steps": 10,
        "key_enzymes": ["hexokinase", "PFK-1", "aldolase", "pyruvate kinase"],
        "irreversible_steps": ["hexokinase (step 1)", "PFK-1 (step 3)", "pyruvate kinase (step 10)"],
        "notes": "Glucose (6C) split by aldolase into G3P+DHAP (3C each). Net = 2 ATP, 2 NADH, 2 pyruvate.",
    },
    "tca": {
        "name": "TCA cycle (Krebs cycle)", "location": "mitochondrial matrix",
        "input": "acetyl-CoA (2C) + oxaloacetate (4C)", "output": "2 CO2 + oxaloacetate (regenerated)",
        "net_atp": 0, "nadh": 3, "fadh2": 1, "gtp": 1, "steps": 8,
        "key_enzymes": ["citrate synthase", "isocitrate dehydrogenase", "alpha-ketoglutarate dehydrogenase", "succinate dehydrogenase"],
        "irreversible_steps": ["citrate synthase", "isocitrate dehydrogenase", "alpha-ketoglutarate dehydrogenase"],
        "notes": "Per turn: 3 NADH + 1 FADH2 + 1 GTP. Per glucose (2 acetyl-CoA): multiply by 2.",
    },
    "oxidative_phosphorylation": {
        "name": "Oxidative phosphorylation", "location": "inner mitochondrial membrane",
        "input": "NADH, FADH2, O2", "output": "ATP, H2O",
        "conversion": {"NADH": 2.5, "FADH2": 1.5},
        "notes": "NADH -> Complex I -> ~2.5 ATP. FADH2 -> Complex II -> ~1.5 ATP. Varies by shuttle.",
    },
    "pentose_phosphate_pathway": {
        "name": "Pentose phosphate pathway (PPP)", "location": "cytoplasm",
        "input": "glucose-6-phosphate", "output": "ribose-5-phosphate + 2 NADPH + CO2",
        "phases": {"oxidative": "G6P -> ribulose-5-P + 2 NADPH + CO2 (irreversible)",
                   "non-oxidative": "ribulose-5-P <-> ribose-5-P, fructose-6-P, G3P (reversible)"},
        "notes": "C1 of glucose released as CO2 in oxidative phase. Primary NADPH and ribose-5-P source.",
    },
    "gluconeogenesis": {
        "name": "Gluconeogenesis", "location": "cytoplasm + mitochondria",
        "input": "2 pyruvate", "output": "glucose", "cost": "4 ATP + 2 GTP + 2 NADH",
        "bypass_enzymes": ["pyruvate carboxylase", "PEP carboxykinase",
                           "fructose-1,6-bisphosphatase", "glucose-6-phosphatase"],
        "notes": "Not simply reverse glycolysis; uses 4 bypass reactions.",
    },
    "beta_oxidation": {
        "name": "Fatty acid beta-oxidation", "location": "mitochondrial matrix",
        "input": "fatty acyl-CoA", "output": "acetyl-CoA units + NADH + FADH2",
        "per_round": {"NADH": 1, "FADH2": 1, "acetyl_CoA": 1},
        "notes": "Cn fatty acid: (n/2-1) rounds, n/2 acetyl-CoA, (n/2-1) FADH2+NADH. Activation costs 2 ATP.",
    },
}

# --- 2. Isotope tracer data ---
GLUCOSE_CARBON_FATES = {
    "C1": "Released as CO2 in PPP oxidative phase; in glycolysis -> C3 of pyruvate",
    "C2": "Becomes C2 of pyruvate -> methyl carbon of acetyl-CoA",
    "C3": "Becomes C1 of pyruvate (carbonyl) -> released as CO2 by pyruvate dehydrogenase",
    "C4": "Becomes C1 of pyruvate (carbonyl) -> released as CO2 by pyruvate dehydrogenase",
    "C5": "Becomes C2 of pyruvate -> methyl carbon of acetyl-CoA",
    "C6": "Released as CO2 in PPP oxidative phase; in glycolysis -> C3 of pyruvate",
}
TRACER_RULES = {
    "first_CO2_release": "C3/C4 released first (pyruvate decarboxylation). C1/C6 first if glucose enters PPP.",
    "acetyl_CoA_carbons": "C2 and C5 of glucose become the two carbons of acetyl group in acetyl-CoA.",
    "ppp_CO2": "C1 of glucose -> CO2 in the oxidative phase of PPP.",
    "tca_CO2_first_turn": "First TCA turn: CO2 from oxaloacetate carbons, not incoming acetyl-CoA. Acetyl carbons released in later turns.",
}


def parse_labeled_carbons(substrate_str: str) -> list[int]:
    """Extract labeled carbon positions from e.g. '1,4-13C-glucose'."""
    carbons = []
    for p in substrate_str.replace(" ", "").split("-"):
        if "13C" in p.upper() or p.lower() in ("glucose", "pyruvate", "acetylcoa"):
            continue
        for num in p.split(","):
            if num.isdigit():
                carbons.append(int(num))
    return sorted(carbons)


def trace_carbons(substrate_str: str, pathway: str) -> dict:
    """Trace 13C-labeled carbons through a pathway."""
    carbons = parse_labeled_carbons(substrate_str)
    if not carbons:
        return {"error": f"Could not parse labeled carbons from '{substrate_str}'"}
    fates = [{"carbon": f"C{c}", "fate": GLUCOSE_CARBON_FATES.get(f"C{c}", f"No data for C{c}")} for c in carbons]
    co2, retained = [], []
    if pathway in ("glycolysis", "tca", "pyruvate_dehydrogenase"):
        for c in carbons:
            if c in (3, 4):
                co2.append(f"C{c} -> CO2 via pyruvate decarboxylation")
            elif c in (2, 5):
                retained.append(f"C{c} -> acetyl-CoA (enters TCA)")
            elif c in (1, 6):
                retained.append(f"C{c} -> C3 of pyruvate (stays in carbon skeleton)")
    elif pathway in ("ppp", "pentose_phosphate_pathway"):
        for c in carbons:
            if c == 1:
                co2.append(f"C{c} -> CO2 in PPP oxidative phase")
            else:
                retained.append(f"C{c} -> remains in sugar phosphate skeleton")
    return {
        "substrate": substrate_str, "labeled_carbons": carbons, "pathway": pathway,
        "carbon_fates": fates, "rules": TRACER_RULES,
        "co2_release": co2 or ["None of the labeled carbons released as CO2 in this pathway"],
        "retained": retained,
    }


# --- 3. ATP yield calculations ---
def atp_glucose(conditions: str) -> dict:
    """ATP yield from complete glucose oxidation."""
    if conditions == "anaerobic":
        return {"substrate": "glucose", "conditions": "anaerobic (fermentation)",
                "total_atp": 2, "breakdown": {"glycolysis_net": 2},
                "notes": "Pyruvate -> lactate (or ethanol); NADH recycled, not oxidized."}
    bd = {"glycolysis_net_atp": 2,
          "glycolysis_nadh": {"count": 2, "atp_each": 2.5, "subtotal": 5.0},
          "pyruvate_dehydrogenase_nadh": {"count": 2, "atp_each": 2.5, "subtotal": 5.0},
          "tca_nadh": {"count": 6, "atp_each": 2.5, "subtotal": 15.0},
          "tca_fadh2": {"count": 2, "atp_each": 1.5, "subtotal": 3.0},
          "tca_gtp": {"count": 2, "atp_each": 1.0, "subtotal": 2.0}}
    total = sum(v["subtotal"] if isinstance(v, dict) else v for v in bd.values())
    return {"substrate": "glucose", "conditions": "aerobic", "total_atp": total,
            "range": "30-32 ATP (shuttle-dependent)", "breakdown": bd,
            "notes": "Malate-aspartate shuttle: ~32 ATP. Glycerol-3-phosphate shuttle: ~30 ATP."}


KNOWN_FATTY_ACIDS = {
    "palmitate": 16, "palmitoyl": 16, "palmitic": 16,
    "stearate": 18, "stearic": 18, "myristate": 14, "myristic": 14,
    "laurate": 12, "lauric": 12, "oleate": 18, "oleic": 18,
}


def atp_fatty_acid(name: str, carbons: int, conditions: str) -> dict:
    """ATP yield from fatty acid beta-oxidation + TCA."""
    if conditions == "anaerobic":
        return {"error": "Fatty acid oxidation requires O2 (aerobic only)."}
    rounds = carbons // 2 - 1
    acetyl_coa = carbons // 2
    activation_cost = 2
    total_nadh = rounds + acetyl_coa * 3
    total_fadh2 = rounds + acetyl_coa
    total_gtp = acetyl_coa
    gross = total_nadh * 2.5 + total_fadh2 * 1.5 + total_gtp
    return {"substrate": name, "carbons": carbons, "conditions": "aerobic",
            "beta_oxidation_rounds": rounds, "acetyl_CoA_produced": acetyl_coa,
            "activation_cost_atp": activation_cost,
            "total_nadh": total_nadh, "total_fadh2": total_fadh2, "total_gtp": total_gtp,
            "gross_atp": gross, "net_atp": gross - activation_cost}


def calc_atp(substrate: str, conditions: str) -> dict:
    """Route ATP calculation based on substrate."""
    sub = substrate.lower().strip()
    if sub == "glucose":
        return atp_glucose(conditions)
    fa_carbons = KNOWN_FATTY_ACIDS.get(sub)
    if fa_carbons:
        return atp_fatty_acid(substrate, fa_carbons, conditions)
    return {"error": f"Unknown substrate '{substrate}'. Known: glucose, {', '.join(sorted(KNOWN_FATTY_ACIDS))}"}


# --- CLI ---
def main():
    p = argparse.ArgumentParser(description="Metabolism reference tool")
    p.add_argument("--type", required=True, choices=["pathway", "tracer", "atp"])
    p.add_argument("--name", help="Pathway name (for --type pathway)")
    p.add_argument("--substrate", help="Substrate (for --type tracer/atp)")
    p.add_argument("--pathway", help="Pathway to trace through (for --type tracer)")
    p.add_argument("--conditions", default="aerobic", choices=["aerobic", "anaerobic"])
    args = p.parse_args()

    if args.type == "pathway":
        name = (args.name or "").lower().replace(" ", "_")
        result = PATHWAYS.get(name, {"error": f"Unknown pathway '{args.name}'", "available": list(PATHWAYS)})
    elif args.type == "tracer":
        if not args.substrate:
            result = {"error": "--substrate required for tracer mode"}
        else:
            result = trace_carbons(args.substrate, (args.pathway or "glycolysis").lower().replace(" ", "_"))
    elif args.type == "atp":
        if not args.substrate:
            result = {"error": "--substrate required for atp mode"}
        else:
            result = calc_atp(args.substrate, args.conditions)
    else:
        result = {"error": "Invalid type"}
    print(json.dumps(result, indent=2, default=str))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Detailed test to understand the actual response structures
"""

from tooluniverse import ToolUniverse
import json

tu = ToolUniverse()
tu.load_tools()

# Test 1: HMDB_search detailed
print("="*80)
print("TEST 1: HMDB_search response structure")
print("="*80)
result = tu.tools.HMDB_search(operation="search", query="glucose")
print(json.dumps(result, indent=2))

print("\n" + "="*80)
print("TEST 2: metabolights_get_study response structure")
print("="*80)
result = tu.tools.metabolights_get_study(study_id="MTBLS1")
print(json.dumps(result, indent=2)[:2000])

print("\n" + "="*80)
print("TEST 3: PubChem correct parameter")
print("="*80)
# Check tool config
tool = tu.all_tool_dict['PubChem_get_CID_by_compound_name']
print(f"Tool parameters: {tool.parameters}")

#!/usr/bin/env python3
"""
Test script for Metabolomics skill
Verifies the complete pipeline works correctly
"""

import sys
import os

# Add parent directory to path to import python_implementation
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from python_implementation import metabolomics_analysis_pipeline

def test_metabolite_analysis():
    """Test metabolite identification and annotation"""
    print("\n" + "="*80)
    print("TEST 1: Metabolite Analysis")
    print("="*80)

    output = metabolomics_analysis_pipeline(
        metabolite_list=["glucose", "lactate"],
        output_file="test1_metabolites.md"
    )

    # Verify output file created
    assert os.path.exists(output), f"Output file {output} not created"

    # Verify report has expected sections
    with open(output, 'r') as f:
        content = f.read()
        assert "Metabolomics Research Analysis Report" in content, "Missing report header"
        assert "Metabolite Identification" in content or "no data" in content.lower(), "Missing Phase 1"
        assert "glucose" in content.lower(), "Missing metabolite in report"

        # Validate actual data (not just "N/A" or errors)
        assert "PubChem CID" in content, "Missing PubChem data"
        assert "Formula" in content, "Missing chemical formula"
        assert "Molecular Weight" in content, "Missing molecular weight"
        assert "Error querying HMDB: 0" not in content, "HMDB parsing error still present"

    print(f"✅ Test 1 PASSED: {output}")

def test_study_retrieval():
    """Test study retrieval from MetaboLights"""
    print("\n" + "="*80)
    print("TEST 2: Study Retrieval")
    print("="*80)

    output = metabolomics_analysis_pipeline(
        study_id="MTBLS1",
        output_file="test2_study.md"
    )

    assert os.path.exists(output), f"Output file {output} not created"

    with open(output, 'r') as f:
        content = f.read()
        assert "Study Details" in content or "Study" in content, "Missing study section"
        assert "MTBLS1" in content, "Missing study ID"

        # Validate actual study data
        assert "Study Status" in content, "Missing study status field"
        assert "MetaboLights" in content, "Missing database attribution"
        # Check we got real data, not all N/A
        assert content.count("N/A") < 5, "Too many N/A fields - API parsing may be broken"

    print(f"✅ Test 2 PASSED: {output}")

def test_study_search():
    """Test study search functionality"""
    print("\n" + "="*80)
    print("TEST 3: Study Search")
    print("="*80)

    output = metabolomics_analysis_pipeline(
        search_query="glucose",
        output_file="test3_search.md"
    )

    assert os.path.exists(output), f"Output file {output} not created"

    with open(output, 'r') as f:
        content = f.read()
        assert "Study Search" in content or "Search" in content, "Missing search section"

    print(f"✅ Test 3 PASSED: {output}")

def test_comprehensive_analysis():
    """Test comprehensive analysis with multiple inputs"""
    print("\n" + "="*80)
    print("TEST 4: Comprehensive Analysis")
    print("="*80)

    output = metabolomics_analysis_pipeline(
        metabolite_list=["glucose", "pyruvate"],
        study_id="MTBLS1",
        search_query="diabetes",
        output_file="test4_comprehensive.md"
    )

    assert os.path.exists(output), f"Output file {output} not created"

    # Check report contains all expected sections
    with open(output, 'r') as f:
        content = f.read()

        # Required sections
        assert "# Metabolomics Research Analysis Report" in content, "Missing report title"
        assert "Generated" in content, "Missing timestamp"

        # Multiple phases
        section_count = content.count("##")
        assert section_count >= 3, f"Expected at least 3 sections, found {section_count}"

        # Data quality
        assert len(content) > 500, "Report seems too short"

        # Validate actual data is present (not just errors/N/A)
        assert "PubChem CID" in content, "Missing metabolite data"
        assert "Formula" in content, "Missing chemical formulas"
        assert "Study Status" in content, "Missing study status"
        assert "Error querying HMDB: 0" not in content, "HMDB parsing bug still present"

        # Check data completeness
        metabolite_count = content.count("### Metabolite:")
        assert metabolite_count == 2, f"Expected 2 metabolites, found {metabolite_count}"

    print(f"✅ Test 4 PASSED: {output}")

def main():
    """Run all tests"""
    print("\n" + "="*80)
    print("METABOLOMICS SKILL TEST SUITE")
    print("="*80)

    tests = [
        ("Metabolite Analysis", test_metabolite_analysis),
        ("Study Retrieval", test_study_retrieval),
        ("Study Search", test_study_search),
        ("Comprehensive Analysis", test_comprehensive_analysis),
    ]

    results = {}
    for name, test_func in tests:
        try:
            test_func()
            results[name] = "✅ PASS"
        except Exception as e:
            print(f"\n❌ EXCEPTION in {name}: {e}")
            results[name] = f"❌ FAIL: {str(e)[:100]}"

    # Summary
    print("\n" + "="*80)
    print("TEST SUMMARY")
    print("="*80)
    for name, result in results.items():
        print(f"{name:30} {result}")

    # Overall status
    passed = sum(1 for r in results.values() if "PASS" in r)
    total = len(results)
    pass_rate = (passed / total) * 100

    print(f"\n{'='*80}")
    print(f"PASS RATE: {passed}/{total} ({pass_rate:.0f}%)")
    print(f"{'='*80}")

    if pass_rate == 100:
        print("\n✅ ALL TESTS PASSED - Skill is ready to use!")
        return 0
    else:
        print("\n⚠️  SOME TESTS FAILED - Review failures before release")
        return 1

if __name__ == "__main__":
    sys.exit(main())

#!/usr/bin/env python3
"""
Debug script to test individual tools and identify issues
"""

from tooluniverse import ToolUniverse
import json

print("="*80)
print("METABOLOMICS TOOLS DEBUG TEST")
print("="*80)

# Initialize ToolUniverse
tu = ToolUniverse()
tu.load_tools()

# Check which metabolomics tools are available
print("\n[1] Checking available metabolomics tools...")
print("-" * 80)

hmdb_tools = [name for name in tu.all_tool_dict.keys() if 'HMDB' in name]
metabolights_tools = [name for name in tu.all_tool_dict.keys() if 'metabolights' in name.lower()]
workbench_tools = [name for name in tu.all_tool_dict.keys() if 'Metabolomics' in name]
pubchem_tools = [name for name in tu.all_tool_dict.keys() if 'PubChem' in name]

print(f"\nHMDB tools ({len(hmdb_tools)}): {hmdb_tools}")
print(f"MetaboLights tools ({len(metabolights_tools)}): {metabolights_tools}")
print(f"Metabolomics Workbench tools ({len(workbench_tools)}): {workbench_tools}")
print(f"PubChem tools ({len(pubchem_tools)}): {pubchem_tools}")

# Test HMDB_search
print("\n" + "="*80)
print("[2] Testing HMDB_search with 'glucose'...")
print("-" * 80)
try:
    result = tu.tools.HMDB_search(operation="search", query="glucose")
    print(f"Result type: {type(result)}")
    print(f"Result keys: {result.keys() if isinstance(result, dict) else 'Not a dict'}")
    print(f"Result: {json.dumps(result, indent=2)[:500]}...")
except Exception as e:
    print(f"ERROR: {e}")
    import traceback
    traceback.print_exc()

# Test metabolights_list_studies
print("\n" + "="*80)
print("[3] Testing metabolights_list_studies...")
print("-" * 80)
try:
    result = tu.tools.metabolights_list_studies(size=3)
    print(f"Result type: {type(result)}")
    if isinstance(result, dict):
        print(f"Result keys: {result.keys()}")
        print(f"Result: {json.dumps(result, indent=2)[:500]}...")
    elif isinstance(result, list):
        print(f"List length: {len(result)}")
        print(f"First 3 items: {result[:3]}")
except Exception as e:
    print(f"ERROR: {e}")
    import traceback
    traceback.print_exc()

# Test metabolights_get_study
print("\n" + "="*80)
print("[4] Testing metabolights_get_study with 'MTBLS1'...")
print("-" * 80)
try:
    result = tu.tools.metabolights_get_study(study_id="MTBLS1")
    print(f"Result type: {type(result)}")
    if isinstance(result, dict):
        print(f"Result keys: {result.keys()}")
        print(f"Result: {json.dumps(result, indent=2)[:500]}...")
except Exception as e:
    print(f"ERROR: {e}")
    import traceback
    traceback.print_exc()

# Test metabolights_search_studies
print("\n" + "="*80)
print("[5] Testing metabolights_search_studies with 'diabetes'...")
print("-" * 80)
try:
    result = tu.tools.metabolights_search_studies(query="diabetes")
    print(f"Result type: {type(result)}")
    if isinstance(result, dict):
        print(f"Result keys: {result.keys()}")
        data = result.get('data', [])
        print(f"Data type: {type(data)}")
        print(f"Data length: {len(data) if isinstance(data, list) else 'N/A'}")
        print(f"First 3 items: {data[:3] if isinstance(data, list) else data}")
except Exception as e:
    print(f"ERROR: {e}")
    import traceback
    traceback.print_exc()

# Test PubChem
print("\n" + "="*80)
print("[6] Testing PubChem_get_CID_by_compound_name with 'glucose'...")
print("-" * 80)
try:
    result = tu.tools.PubChem_get_CID_by_compound_name(compound_name="glucose")
    print(f"Result type: {type(result)}")
    if isinstance(result, dict):
        print(f"Result keys: {result.keys()}")
        print(f"Result: {json.dumps(result, indent=2)[:500]}...")
except Exception as e:
    print(f"ERROR: {e}")
    import traceback
    traceback.print_exc()

print("\n" + "="*80)
print("DEBUG TEST COMPLETE")
print("="*80)