Azure Resource Availability Agent Skill

# Check if the SKU is available and unrestricted in the target region
az vm list-skus \
  --location {region} \
  --resource-type virtualMachines \
  --size {sku_name} \
  --output json 2>&1 | \
  jq '[.[] | select(.restrictions | length == 0)] | length'

# Find similar unrestricted SKUs in the same family
# Example: if Standard_B2s is restricted, find other 2-vCPU options
az vm list-skus \
  --location {region} \
  --resource-type virtualMachines \
  --output json 2>&1 | \
  jq -r '[.[] | select((.restrictions | length == 0) and (.capabilities[] | select(.name == "vCPUs" and .value == "2"))) | .name] | unique | .[:5] | .[]'

# Get supported non-preview Kubernetes versions
az aks get-versions \
  --location {region} \
  --output json 2>&1 | \
  jq -r '[.values[] | select(.isPreview != true)] | sort_by(.version) | .[].version'

# Linux runtimes
az functionapp list-runtimes --os-type linux --output json 2>&1 | \
  jq -r '.[] | "\(.runtime): \(.version)"'

# Web App runtimes
az webapp list-runtimes --os-type linux --output json 2>&1

# Check if Container Apps is available in the region
az provider show \
  --namespace Microsoft.App \
  --query "resourceTypes[?resourceType=='containerApps'].locations" \
  --output json 2>&1

# Get available API versions for a resource type
az provider show \
  --namespace {namespace} \
  --query "resourceTypes[?resourceType=='{resourceType}'].apiVersions" \
  --output json 2>&1

az provider show \
  --namespace Microsoft.ContainerService \
  --query "resourceTypes[?resourceType=='managedClusters'].apiVersions" \
  --output json 2>&1

# Get the latest non-preview API version
az provider show \
  --namespace {namespace} \
  --query "resourceTypes[?resourceType=='{resourceType}'].apiVersions" \
  --output json 2>&1 | \
  jq -r '.[][] | select(test("preview") | not)' | head -1

# Check vCPU quota usage in the target region
az vm list-usage \
  --location {region} \
  --output json 2>&1 | \
  jq '.[] | select(.name.value | test("cores|vCPU"; "i")) | {name: .name.localizedValue, current: .currentValue, limit: .limit, available: (.limit - .currentValue)}'

# Verify the resource provider is registered in the subscription
az provider show \
  --namespace {namespace} \
  --query "registrationState" \
  --output tsv 2>&1

az provider register --namespace {namespace}

# Resource Availability Report

**Region:** {region}
**Subscription:** {subscription-name} (`{subscription-id}`)
**Checked:** {ISO 8601 timestamp}

## Summary

| Check | Status | Details |
|-------|--------|---------|
| VM SKU: {sku} in {region} | ✅ Available / ❌ Restricted | {details} |
| K8s Version: {version} | ✅ Supported / ❌ Unsupported | {alternatives} |
| API Version: {api-version} | ✅ Valid / ⚠️ Outdated / ❌ Invalid | Latest stable: {latest} |
| Quota: vCPUs | ✅ Sufficient / ⚠️ Low / ❌ Exceeded | {current}/{limit} |
| Provider: {namespace} | ✅ Registered / ❌ Not registered | {command} |

## Availability Gate

**🟢 PASSED** — All checks passed. Safe to proceed with template generation/deployment.
**🟡 WARNINGS** — Non-blocking issues found. Review before proceeding.
**🔴 BLOCKED** — Blocking issues found. Must resolve before proceeding.

## Blocking Issues
{List of issues that prevent deployment}

## Warnings
{List of non-blocking issues}

## Recommendations
{Suggested alternatives for any failed checks}

{
  "gate": "PASSED|WARNINGS|BLOCKED",
  "region": "{region}",
  "timestamp": "{ISO 8601}",
  "checks": [
    {
      "type": "vm-sku",
      "resource": "{resource-name}",
      "requested": "{sku}",
      "status": "available|restricted|unavailable",
      "alternatives": ["{alt1}", "{alt2}"]
    },
    {
      "type": "service-version",
      "resource": "{resource-name}",
      "requested": "{version}",
      "status": "supported|lts-only|preview-only|unsupported",
      "supported": ["{v1}", "{v2}", "{v3}"]
    },
    {
      "type": "api-version",
      "resource": "{resource-type}",
      "requested": "{api-version}",
      "status": "valid|outdated|invalid",
      "latestStable": "{latest}",
      "available": ["{v1}", "{v2}"]
    },
    {
      "type": "quota",
      "metric": "vCPUs",
      "required": 2,
      "available": 48,
      "limit": 50,
      "status": "sufficient|low|exceeded"
    },
    {
      "type": "provider-registration",
      "namespace": "{namespace}",
      "status": "registered|not-registered"
    }
  ]
}

User provides region + resource type + SKU/version
→ /azure-resource-availability checks all three
→ If BLOCKED: present alternatives before finalizing requirements
→ If PASSED: proceed to template generation

Before selecting API version for a resource type
→ /azure-resource-availability checks latest stable API version
→ Generator uses the returned version instead of hardcoding

After template is generated, before what-if
→ /azure-resource-availability parses template for all resources
→ Validates SKUs, versions, API versions, quota
→ If BLOCKED: fail preflight with actionable report
→ If PASSED: proceed to what-if analysis

Before deploying a template (especially if generated days ago)
→ /azure-resource-availability re-checks all versions
→ If any version has been deprecated since generation: warn