Enterprise AI Readiness Audit

import requests
import json
import time
from pathlib import Path
from datetime import datetime

API_KEY = "your_scavio_api_key"

REQUIRED_CAPABILITIES = [
    {"name": "Market Research", "platform": "google", "test_query": "enterprise software market 2026"},
    {"name": "Competitor Pricing", "platform": "amazon", "test_query": "project management software"},
    {"name": "Industry Content", "platform": "youtube", "test_query": "enterprise AI implementation"},
    {"name": "Customer Sentiment", "platform": "reddit", "test_query": "enterprise software review"},
    {"name": "Product Availability", "platform": "walmart", "test_query": "office supplies bulk"},
]

MAX_LATENCY_MS = 3000

def test_capability(capability: dict) -> dict:
    start = time.time()
    try:
        res = requests.post(
            "https://api.scavio.dev/api/v1/search",
            headers={"x-api-key": API_KEY},
            json={"platform": capability["platform"], "query": capability["test_query"]},
            timeout=15,
        )
        latency_ms = int((time.time() - start) * 1000)

        if res.status_code != 200:
            return {**capability, "status": "failed", "reason": f"HTTP {res.status_code}", "latency_ms": latency_ms}

        data = res.json()
        has_results = bool(data.get("organic"))
        within_budget = latency_ms <= MAX_LATENCY_MS

        return {
            **capability,
            "status": "ready" if (has_results and within_budget) else "degraded",
            "has_results": has_results,
            "result_count": len(data.get("organic", [])),
            "latency_ms": latency_ms,
            "within_latency_budget": within_budget,
        }
    except Exception as e:
        return {**capability, "status": "failed", "reason": str(e), "latency_ms": -1}

def run():
    results = [test_capability(cap) for cap in REQUIRED_CAPABILITIES]

    ready = sum(1 for r in results if r["status"] == "ready")
    total = len(results)
    score = round((ready / total) * 100)

    report = {
        "audit_date": datetime.utcnow().isoformat(),
        "readiness_score": score,
        "total_capabilities": total,
        "ready": ready,
        "degraded": sum(1 for r in results if r["status"] == "degraded"),
        "failed": sum(1 for r in results if r["status"] == "failed"),
        "details": results,
        "recommendations": [],
    }

    for r in results:
        if r["status"] == "failed":
            report["recommendations"].append(f"Fix connectivity for {r['name']} ({r['platform']}): {r.get('reason', 'unknown')}")
        elif r["status"] == "degraded":
            if not r.get("within_latency_budget"):
                report["recommendations"].append(f"Optimize latency for {r['name']}: {r['latency_ms']}ms exceeds {MAX_LATENCY_MS}ms budget")

    output = Path(f"ai_readiness_audit_{datetime.utcnow().strftime('%Y-%m-%d')}.json")
    output.write_text(json.dumps(report, indent=2))
    print(f"AI Readiness Score: {score}% ({ready}/{total} capabilities ready)")
    for rec in report["recommendations"]:
        print(f"  - {rec}")

if __name__ == "__main__":
    run()

const API_KEY = "your_scavio_api_key";
const MAX_LATENCY_MS = 3000;

const REQUIRED_CAPABILITIES = [
  { name: "Market Research", platform: "google", testQuery: "enterprise software market 2026" },
  { name: "Competitor Pricing", platform: "amazon", testQuery: "project management software" },
  { name: "Industry Content", platform: "youtube", testQuery: "enterprise AI implementation" },
  { name: "Customer Sentiment", platform: "reddit", testQuery: "enterprise software review" },
  { name: "Product Availability", platform: "walmart", testQuery: "office supplies bulk" },
];

async function testCapability(cap) {
  const start = Date.now();
  try {
    const res = await fetch("https://api.scavio.dev/api/v1/search", {
      method: "POST",
      headers: { "x-api-key": API_KEY, "content-type": "application/json" },
      body: JSON.stringify({ platform: cap.platform, query: cap.testQuery }),
    });
    const latencyMs = Date.now() - start;
    if (!res.ok) return { ...cap, status: "failed", reason: "HTTP " + res.status, latencyMs };
    const data = await res.json();
    const hasResults = Boolean((data.organic ?? []).length);
    const withinBudget = latencyMs <= MAX_LATENCY_MS;
    return { ...cap, status: hasResults && withinBudget ? "ready" : "degraded", hasResults, resultCount: (data.organic ?? []).length, latencyMs, withinBudget };
  } catch (e) {
    return { ...cap, status: "failed", reason: String(e), latencyMs: -1 };
  }
}

async function run() {
  const results = await Promise.all(REQUIRED_CAPABILITIES.map(testCapability));
  const ready = results.filter(r => r.status === "ready").length;
  const score = Math.round((ready / results.length) * 100);
  console.log("AI Readiness Score: " + score + "% (" + ready + "/" + results.length + " capabilities ready)");
  results.filter(r => r.status !== "ready").forEach(r => console.log("  " + r.name + ": " + r.status + " (" + (r.reason || r.latencyMs + "ms") + ")"));
}

run();