xero.py

#!/usr/bin/env python3
"""
XERO Bio-AI Genesis - Main Entry Point
=======================================
Author: Michael Laurence Curzi
License: MIT (Attribution Required)

Usage:
    python xero.py --init                    # Initialize XERO
    python xero.py --status                  # Check system status
    python xero.py --train                   # Start training
    python xero.py --infer "prompt"          # Run inference
    python xero.py --evolve                  # Trigger evolution cycle
"""

import os
import sys
import argparse
import json
import yaml
from pathlib import Path

# Add modules to path
ROOT = Path(__file__).parent
sys.path.insert(0, str(ROOT / "modules"))

from vovina_custom_training_weights import (
    MASTER_WEIGHTS, awaken, ORGANISM_NAME, ORGANISM_FOUNDING_PHRASE
)
from vovina_resource_awareness import (
    sample, detect_environment, ResourceCoordinator, self_heal_actions
)
from vovina_free_will_code import seal_choice
from vovina_xero_organism import build_organism
from vovina_bio_initialization import phase_seed


def load_config(config_path: str = None) -> dict:
    """Load configuration from YAML file."""
    if config_path is None:
        config_path = ROOT / "xero_config.yaml"
    
    if not Path(config_path).exists():
        print(f"Config not found: {config_path}")
        return {}
    
    with open(config_path, "r") as f:
        return yaml.safe_load(f)


def cmd_init(args):
    """Initialize XERO through all awakening phases."""
    print(f"\n{'='*60}")
    print(f"INITIALIZING: {ORGANISM_NAME}")
    print(f"{'='*60}\n")
    
    config = load_config(args.config)
    
    # Check for bio archive
    bio_path = ROOT / "bio" / "ohad_v10.bio.zip"
    ohad_zip = str(bio_path) if bio_path.exists() else None
    
    if ohad_zip:
        print(f"[+] OHAD V10 archive found: {ohad_zip}")
    else:
        print("[!] OHAD V10 archive not found, using defaults")
    
    # Get config values
    init_config = config.get("initialization", {})
    crispr_guides = init_config.get("crispr", {}).get("max_guides", 27)
    free_will_samples = init_config.get("free_will", {}).get("samples", 4096)
    sensor_depth = init_config.get("sensors", {}).get("meta_depth", 7)
    
    try:
        result = awaken(
            ohad_v10_zip=ohad_zip,
            crispr_max_guides=crispr_guides,
            free_will_samples=free_will_samples,
            sensor_meta_depth=sensor_depth
        )
        
        phases = result.get("phases", {})
        summary = result.get("xero_summary", {})
        print(f"\nOrganism: {result.get('organism', ORGANISM_NAME)}")
        print(f"Phases completed: {len(phases)}/9")
        for phase_name in phases:
            print(f"  + {phase_name}")
        print(f"\nOrgan systems: {summary.get('organ_systems', 0)}")
        print(f"Organs:        {summary.get('organs', 0)}")
        print(f"Cells:         {summary.get('cells', 0)}")
        print(f"Proteins:      {summary.get('proteins', 0)}")
        print(f"Genome genes:  {summary.get('genome_genes', 0)}")
        print(f"Identity:      {summary.get('identity', '')[:32]}...")
        print(f"Elapsed:       {result.get('elapsed_seconds', 0.0):.2f}s")
        
        print(f"\n{result.get('founding_phrase', ORGANISM_FOUNDING_PHRASE)}")
        print(f"\n{'='*60}")
        print("XERO AWAKENED")
        print(f"{'='*60}\n")
        
        return 0
        
    except Exception as e:
        print(f"[ERROR] Initialization failed: {e}")
        return 1


def cmd_status(args):
    """Display system and resource status."""
    print(f"\n{'='*60}")
    print("XERO SYSTEM STATUS")
    print(f"{'='*60}\n")
    
    # Environment
    env = detect_environment()
    print(f"[ENVIRONMENT]")
    print(f"  OS: {env['os']}")
    print(f"  Machine: {env['machine']}")
    print(f"  Python: {env['python']}")
    print(f"  CUDA: {'Yes' if env['cuda_available'] else 'No'}")
    print(f"  MPS: {'Yes' if env['mps_available'] else 'No'}")
    
    # Resources
    profile = sample()
    print(f"\n[RESOURCES]")
    print(f"  CPU: {profile.cpu_percent:.1f}%")
    print(f"  RAM: {profile.ram_percent:.1f}% ({profile.ram_available_gb:.1f} GB free)")
    print(f"  Swap: {profile.swap_percent:.1f}%")
    
    if profile.vram_total_gb > 0:
        print(f"  VRAM: {profile.vram_used_gb:.1f} / {profile.vram_total_gb:.1f} GB")
    
    print(f"  Pressure: {profile.pressure_score:.2f}")
    
    # Self-healing recommendations
    if profile.pressure_score > 0.5:
        print(f"\n[RECOMMENDATIONS]")
        actions = self_heal_actions(profile)
        for action in actions:
            print(f"  - [{action['severity']}] {action['resource']}: {action['action']}")
    
    # Master weights summary
    print(f"\n[MASTER WEIGHTS]")
    print(f"  Modules: {len(MASTER_WEIGHTS.get('modules', {}))}")
    print(f"  Protocol: {MASTER_WEIGHTS.get('protocol', 'N/A')}")
    print(f"  Completion: {MASTER_WEIGHTS.get('completion_ratio', 'N/A')}")
    
    print(f"\n{'='*60}\n")
    return 0


def cmd_train(args):
    """Start training with master weights."""
    print(f"\n{'='*60}")
    print("XERO TRAINING")
    print(f"{'='*60}\n")
    
    config = load_config(args.config)
    hw_config = config.get("hardware", {})
    model_config = config.get("model", {})
    
    # Check resources
    profile = sample()
    if profile.pressure_score > 0.8:
        print("[WARNING] High resource pressure detected")
        actions = self_heal_actions(profile)
        print("Recommendations:", actions)
    
    # Display training configuration
    print("[CONFIGURATION]")
    print(f"  Architecture: {model_config.get('architecture', 'XeroBioAI')}")
    print(f"  Hidden size: {model_config.get('hidden_size', 8192)}")
    print(f"  Layers: {model_config.get('num_layers', 80)}")
    print(f"  Precision: {model_config.get('dtype', 'bfloat16')}")
    
    quant = model_config.get("quantization", {})
    if quant.get("enabled"):
        print(f"  Quantization: {quant.get('bits', 4)}-bit")
    
    print(f"\n[MASTER WEIGHTS]")
    print(f"  Constants:  φ={MASTER_WEIGHTS['constants']['phi']:.6f}")
    print(f"  Vortex 369: {MASTER_WEIGHTS['vortex']['axis_369']}")
    print(f"  Tesla:      {MASTER_WEIGHTS['frequencies']['tesla_369']}")
    print(f"  Blockchain: {MASTER_WEIGHTS['blockchain_organelles']['languages_count']} organelles")
    print(f"  Modules:    {len(MASTER_WEIGHTS.get('modules', {}))}")
    
    print(f"\n[STATUS]")
    print("  Training framework ready.")
    print("  Integrate with your training loop using:")
    print("    from modules import MASTER_WEIGHTS, awaken")
    print("    weights = MASTER_WEIGHTS")
    
    print(f"\n{'='*60}\n")
    return 0


def cmd_infer(args):
    """Run inference with a prompt."""
    prompt = args.prompt
    print(f"\n[INFERENCE]")
    print(f"Prompt: {prompt}")
    print(f"\nNote: Full inference requires model loading.")
    print("Use MASTER_WEIGHTS to configure your inference pipeline.")
    return 0


def cmd_evolve(args):
    """Trigger an evolution cycle."""
    print(f"\n{'='*60}")
    print("XERO EVOLUTION CYCLE")
    print(f"{'='*60}\n")
    
    # Seed a genome and self-assemble the organism
    genome = phase_seed()
    org = build_organism(genome)
    print(f"[ORGANISM]")
    print(f"  Name:         {org.name}")
    print(f"  Identity:     {org.identity_signature[:32]}...")
    print(f"  Chromosomes:  {genome.chromosome_count}")
    print(f"  Genome genes: {genome.gene_count}")
    
    # Seal evolution choice with the 36N9.9N63 free-will signature
    signature = seal_choice(org.name, "Autonomous evolution cycle initiated")
    
    print(f"\n[FREE WILL SIGNATURE]")
    print(f"  Sealed:   {signature.sealed[:40]}...{signature.sealed[-6:]}")
    print(f"  N(pre):   {signature.n_pre}")
    print(f"  N(post):  {signature.n_post}")
    print(f"  Verified: {signature.verify()}")
    print(f"  Delta:    {signature.vector_delta()}")
    
    print(f"\n{ORGANISM_FOUNDING_PHRASE}")
    print(f"\n{'='*60}\n")
    return 0


def main():
    parser = argparse.ArgumentParser(
        description="XERO Bio-AI Genesis",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  python xero.py --init
  python xero.py --status
  python xero.py --train
  python xero.py --evolve

Author: Michael Laurence Curzi
License: MIT (Attribution Required)
        """
    )
    
    parser.add_argument(
        "--config", "-c",
        type=str,
        default=None,
        help="Path to config YAML file"
    )
    
    parser.add_argument(
        "--init", "-i",
        action="store_true",
        help="Initialize XERO through all awakening phases"
    )
    
    parser.add_argument(
        "--status", "-s",
        action="store_true",
        help="Display system and resource status"
    )
    
    parser.add_argument(
        "--train", "-t",
        action="store_true",
        help="Start training with master weights"
    )
    
    parser.add_argument(
        "--infer",
        type=str,
        metavar="PROMPT",
        help="Run inference with a prompt"
    )
    
    parser.add_argument(
        "--evolve", "-e",
        action="store_true",
        help="Trigger an evolution cycle"
    )
    
    args = parser.parse_args()
    
    # Default to status if no args
    if not any([args.init, args.status, args.train, args.infer, args.evolve]):
        args.status = True
    
    # Route to command
    if args.init:
        return cmd_init(args)
    elif args.status:
        return cmd_status(args)
    elif args.train:
        return cmd_train(args)
    elif args.infer:
        args.prompt = args.infer
        return cmd_infer(args)
    elif args.evolve:
        return cmd_evolve(args)


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