ntn-link-budget calculate --scenario geo --freq 1.5 --distance 36000 --elevation 45

ntn-link-budget optimize --target-margin 10 --scenario haps

ntn-link-budget compare --scenarios geo,leo,haps --freq 2.0

#!/usr/bin/env python3
import sys
import json
import argparse
from typing import Dict, List
import numpy as np

class NTNLinkBudgetSkill:
    """Claude Code skill for NTN link budget calculations"""
    
    def __init__(self):
        self.scenarios = {
            "geo": {"distance": 36000, "elevation": 45, "doppler": 15},
            "leo": {"distance": 600, "elevation": 30, "doppler": 37500},
            "haps": {"distance": 30, "elevation": 60, "doppler": 100},
            "uav": {"distance": 5, "elevation": 70, "doppler": 500}
        }
        
    def calculate_fspl(self, distance_km: float, freq_ghz: float) -> float:
        """Free space path loss calculation"""
        return 20 * np.log10(distance_km) + 20 * np.log10(freq_ghz) + 92.45
        
    def calculate_link_budget(self, params: Dict) -> Dict:
        """Perform link budget calculation"""
        # Default values
        defaults = {
            "tx_power_dbm": 27,
            "tx_antenna_gain_dbi": 3,
            "rx_antenna_gain_dbi": 18,
            "rx_noise_figure_db": 5,
            "bandwidth_mhz": 30,
            "required_snr_db": 10
        }
        
        # Merge with provided params
        config = {**defaults, **params}
        
        # Calculate EIRP
        eirp = config["tx_power_dbm"] + config["tx_antenna_gain_dbi"]
        
        # Calculate path loss
        fspl = self.calculate_fspl(config["distance_km"], config["freq_ghz"])
        atmospheric_loss = 0.5  # Simplified
        
        # Total path loss
        total_loss = fspl + atmospheric_loss + 2  # Implementation margin
        
        # Received power
        rx_power = eirp - total_loss + config["rx_antenna_gain_dbi"]
        
        # Noise floor
        noise_floor = -174 + 10*np.log10(config["bandwidth_mhz"]*1e6) + config["rx_noise_figure_db"]
        
        # SNR and margin
        snr = rx_power - noise_floor
        margin = snr - config["required_snr_db"]
        
        return {
            "eirp_dbm": eirp,
            "path_loss_db": total_loss,
            "rx_power_dbm": rx_power,
            "noise_floor_dbm": noise_floor,
            "snr_db": snr,
            "link_margin_db": margin,
            "status": "PASS" if margin > 0 else "FAIL"
        }
        
    def optimize_for_margin(self, target_margin: float, scenario: str) -> Dict:
        """Find configuration to achieve target margin"""
        base_config = self.scenarios.get(scenario, self.scenarios["geo"])
        
        # Try different configurations
        options = []
        
        for tx_power in [20, 23, 27, 30, 33]:
            for tx_gain in [0, 3, 6, 10]:
                for rx_gain in [10, 15, 18, 20, 25]:
                    config = {
                        **base_config,
                        "tx_power_dbm": tx_power,
                        "tx_antenna_gain_dbi": tx_gain,
                        "rx_antenna_gain_dbi": rx_gain,
                        "freq_ghz": 2.0
                    }
                    
                    result = self.calculate_link_budget(config)
                    
                    if result["link_margin_db"] >= target_margin:
                        options.append({
                            "config": config,
                            "margin": result["link_margin_db"],
                            "cost": tx_power + tx_gain*10 + rx_gain*5  # Cost metric
                        })
                        
        # Sort by cost (lowest first)
        options.sort(key=lambda x: x["cost"])
        
        if options:
            best = options[0]
            return {
                "success": True,
                "configuration": best["config"],
                "achieved_margin": best["margin"],
                "relative_cost": best["cost"]
            }
        else:
            return {
                "success": False,
                "message": f"Cannot achieve {target_margin} dB margin with standard configurations"
            }
            
    def compare_scenarios(self, scenarios: List[str], freq_ghz: float) -> Dict:
        """Compare multiple scenarios"""
        comparison = {}
        
        for scenario in scenarios:
            if scenario not in self.scenarios:
                continue
                
            config = {
                **self.scenarios[scenario],
                "freq_ghz": freq_ghz
            }
            
            result = self.calculate_link_budget(config)
            comparison[scenario] = {
                "distance_km": config["distance_km"],
                "path_loss_db": result["path_loss_db"],
                "link_margin_db": result["link_margin_db"],
                "doppler_hz": self.scenarios[scenario]["doppler"],
                "status": result["status"]
            }
            
        return comparison

def main():
    parser = argparse.ArgumentParser(description="NTN Link Budget Skill")
    parser.add_argument("command", choices=["calculate", "optimize", "compare"])
    parser.add_argument("--scenario", type=str, default="geo")
    parser.add_argument("--freq", type=float, default=2.0)
    parser.add_argument("--distance", type=float)
    parser.add_argument("--elevation", type=float)
    parser.add_argument("--tx-power", type=float)
    parser.add_argument("--target-margin", type=float, default=10)
    parser.add_argument("--scenarios", type=str)
    parser.add_argument("--output", type=str, default="json")
    
    args = parser.parse_args()
    
    skill = NTNLinkBudgetSkill()
    
    if args.command == "calculate":
        params = {
            "freq_ghz": args.freq
        }
        
        if args.scenario in skill.scenarios:
            params.update(skill.scenarios[args.scenario])
            
        if args.distance:
            params["distance_km"] = args.distance
        if args.elevation:
            params["elevation_deg"] = args.elevation
        if args.tx_power:
            params["tx_power_dbm"] = args.tx_power
            
        result = skill.calculate_link_budget(params)
        
        if args.output == "json":
            print(json.dumps(result, indent=2))
        else:
            print(f"Link Margin: {result['link_margin_db']:.1f} dB [{result['status']}]")
            
    elif args.command == "optimize":
        result = skill.optimize_for_margin(args.target_margin, args.scenario)
        print(json.dumps(result, indent=2))
        
    elif args.command == "compare":
        scenarios = args.scenarios.split(",") if args.scenarios else ["geo", "leo", "haps"]
        result = skill.compare_scenarios(scenarios, args.freq)
        
        if args.output == "json":
            print(json.dumps(result, indent=2))
        else:
            # Table output
            print(f"\n{'Scenario':<10} {'Distance':>10} {'Path Loss':>10} {'Margin':>10} {'Doppler':>10} {'Status':<10}")
            print("-" * 70)
            for scenario, data in result.items():
                print(f"{scenario:<10} {data['distance_km']:>10.0f} {data['path_loss_db']:>10.1f} "
                      f"{data['link_margin_db']:>10.1f} {data['doppler_hz']:>10.0f} {data['status']:<10}")

if __name__ == "__main__":
    main()

# In Claude Code environment
result = await run_skill("ntn-link-budget", {
    "command": "calculate",
    "scenario": "haps",
    "freq": 2.0,
    "distance": 30
})

if result["link_margin_db"] < 10:
    # Optimize configuration
    optimized = await run_skill("ntn-link-budget", {
        "command": "optimize",
        "scenario": "haps",
        "target_margin": 10
    })

# Trigger channel emulator configuration based on link budget
if result["status"] == "PASS":
    await mcp_channel.apply_profile({
        "path_loss": result["path_loss_db"],
        "doppler": result["doppler_hz"]
    })

ntn-link-budget test --verbose