SDK-Adoption-Tracker

Was macht SDK-Adoption-Tracker?

Nimm einen SDK-Namen. Durchsuche GitHub nach öffentlichen Repos, die es importieren. Bewerte jedes Repo nach Unternehmenssignal, Aktivität und Rauschanzeigern. Reichere Repos mit starkem Signal mit Besitzer- und Beitragendendaten an. Gib einen bewerteten Adoptionsbericht mit Vertriebskontext für Unternehmensadoptoren aus.

---

Wichtige Regel: Jedes Repo in der Ausgabe muss in der GitHub-Code-Such-API-Antwort vorhanden sein. Jeder Firmenname muss aus dem GitHub-Feld company oder name des Benutzers oder der Organisation stammen. Jeder Beitragenden-Handle muss aus der GitHub-Beitragenden-API-Antwort stammen. Wenn ein Feld in der API leer ist, schreibe "nicht angegeben" – nicht interpretieren, raten oder extrapolieren.

---

Häufige Fehler

Das wird der Agent wollen...	Warum das falsch ist
Code-Suche ohne GITHUB_TOKEN ausführen	Nicht authentifizierte Code-Suche erreicht ein sekundäres Rate-Limit von 3 Anfragen/Minute und schlägt bei jedem sinnvollen Scan fehl. GITHUB_TOKEN ist erforderlich. Stoppe in Schritt 1 mit einer klaren Fehlermeldung, wenn es fehlt.
Forks des SDKs selbst einschließen	Repos, die das SDK forken, sind Beitragende oder Spiegel, keine Adoptoren. Filtere Repos heraus, bei denen fork == true UND der Repo-Name mit dem SDK-Namen übereinstimmt.
Alle 500 rohen Suchergebnisse an die KI senden	Die Code-Suche kann bis zu 500 Ergebnisse zurückgeben, von denen die meisten Rauschen sind. Filtere und bewerte zuerst lokal. Sende nur die Top 20 Repos mit starkem Signal an den KI-Analyseschritt.
Tutorial- und Beispiel-Repos als Adoptoren melden	Repos mit "example", "tutorial", "demo", "learn", "sample", "playground", "starter" im Namen oder in der Beschreibung sind keine Produktionsnutzer. Markiere sie als tutorial_noise und schließe sie von Lead-Briefings aus.
Firmennamen oder Kontakt-Handles erfinden	Jeder Firmenname muss aus dem GitHub-Feld company oder dem Organisationsfeld name stammen. Jeder Beitragenden-Handle muss aus der Beitragenden-API-Antwort stammen. Wenn ein Feld leer ist, schreibe "nicht angegeben".
Ein einziges Importmuster für alle Ökosysteme verwenden	require('sdk') wird Python-Nutzer nicht finden. Erkenne das Ökosystem automatisch aus dem SDK-Namen und erstelle ökosystemspezifische Muster. Frage den Benutzer, wenn die automatische Erkennung mehrdeutig ist.

---

Schritt 1: Setup-Prüfung

if [ -z "$GITHUB_TOKEN" ]; then
  echo "FEHLER: GITHUB_TOKEN wird für die Code-Suche benötigt."
  echo "Füge ein Token unter github.com/settings/tokens hinzu (keine Bereiche für öffentliche Repos nötig)."
  echo "Ohne Token erreicht die GitHub-Code-Suche ein sekundäres Rate-Limit von 3 Anfragen/Minute und schlägt fehl."
  exit 1
fi
echo "GITHUB_TOKEN: gesetzt"
curl -s -H "Authorization: Bearer $GITHUB_TOKEN" \
     -H "Accept: application/vnd.github+json" \
     "https://api.github.com/rate_limit" | python3 -c "
import json, sys
d = json.load(sys.stdin)
search = d['resources']['search']
core = d['resources']['core']
print(f'Search-Rate: {search[\"remaining\"]}/{search[\"limit\"]} verbleibend')
print(f'Core-Rate:   {core[\"remaining\"]}/{core[\"limit\"]} verbleibend')
"

Wenn der verbleibende Suchkontingent 0 ist: Stoppe. Teile dem Benutzer die Reset-Zeit aus X-RateLimit-Reset mit.

---

Schritt 2: Eingabe sammeln

Sammle aus der Konversation:

• SDK-Name (z.B. @company/my-sdk, requests, github.com/org/go-sdk)
• Optional: Ökosystem-Überschreibung (npm, python, go, gem) – wird automatisch erkannt, wenn nicht angegeben
• Optional: Organisation/Benutzer, der von den Ergebnissen ausgeschlossen werden soll (eigene Repos des SDK-Besitzers)
• Optional: Produktkontext-String (wird verwendet, um Vertriebsnachrichten zu personalisieren)

Ökosystem automatisch erkennen:

• Beginnt mit @ oder enthält -: npm
• snake_case ohne / oder -: python
• Enthält github.com/: go
• Andernfalls: Benutzer fragen

Wenn kein SDK-Name angegeben ist: Frage: "Welches SDK oder welche Bibliothek möchtest du verfolgen? Gib den Paketnamen so an, wie er in Import-Anweisungen erscheint (z.B. stripe, @clerk/nextjs, requests)."

python3 << 'PYEOF'
import json, sys, re

sdk_name = "SDK_NAME_HERE"
ecosystem_override = ""  # leer lassen für Auto-Erkennung
exclude_owner = ""       # optional: auszuschließender Besitzername (normalerweise der SDK-Herausgeber)
product_context = ""     # optional: was dein Produkt tut

# Ökosystem automatisch erkennen
if ecosystem_override:
    ecosystem = ecosystem_override
elif sdk_name.startswith("@") or "-" in sdk_name:
    ecosystem = "npm"
elif re.match(r'^[a-z][a-z0-9_]*$', sdk_name):
    ecosystem = "python"
elif "github.com/" in sdk_name:
    ecosystem = "go"
else:
    ecosystem = "generic"

print(f"SDK: {sdk_name}")
print(f"Ökosystem: {ecosystem}")
print(f"Ausgeschlossener Besitzer: {exclude_owner or '(keiner)'}")

with open("/tmp/sat-input.json", "w") as f:
    json.dump({
        "sdk_name": sdk_name,
        "ecosystem": ecosystem,
        "exclude_owner": exclude_owner,
        "product_context": product_context
    }, f)
PYEOF

---

Schritt 3: GitHub-Code-Suche

Überprüfe zuerst auf ein eigenständiges Skript – es erledigt die Schritte 3-5 in einem Aufruf.

ls scripts/fetch.py 2>/dev/null && echo "Skript verfügbar" || echo "Skript nicht gefunden"

Wenn das Skript verfügbar ist, führe es aus und fahre mit Schritt 6 fort:

python3 scripts/fetch.py "$(python3 -c "import json; d=json.load(open('/tmp/sat-input.json')); print(d['sdk_name'])")" \
  --ecosystem "$(python3 -c "import json; d=json.load(open('/tmp/sat-input.json')); print(d['ecosystem'])")" \
  --exclude "$(python3 -c "import json; d=json.load(open('/tmp/sat-input.json')); print(d.get('exclude_owner',''))")" \
  --output /tmp/sat-script-out.json

Dann lade es in das von den Schritten 6-8 erwartete temporäre Dateiformat:

python3 << 'PYEOF'
import json

out = json.load(open("/tmp/sat-script-out.json"))
json.dump(out["raw_results"], open("/tmp/sat-raw-results.json", "w"), indent=2)
json.dump(out["scored"], open("/tmp/sat-scored.json", "w"), indent=2)
json.dump(out["enriched"], open("/tmp/sat-enriched.json", "w"), indent=2)
print(f"Geladen: {len(out['raw_results'])} roh | {len(out['scored'])} bewertet | {len(out['enriched'])} angereichert")
PYEOF

Wenn das Skript nicht verfügbar ist, führe den untenstehenden Inline-Code aus.

Erstelle Importmuster und durchsuche GitHub-Code nach jedem:

python3 << 'PYEOF'
import json, urllib.request, ssl, time, os
from datetime import datetime, timezone

ctx = ssl._create_unverified_context()
token = os.environ["GITHUB_TOKEN"]
headers = {
    "Accept": "application/vnd.github+json",
    "Authorization": f"Bearer {token}",
    "User-Agent": "sdk-adoption-tracker/1.0"
}

data = json.load(open("/tmp/sat-input.json"))
sdk_name = data["sdk_name"]
ecosystem = data["ecosystem"]

# Erstelle Abfragemuster pro Ökosystem
if ecosystem == "npm":
    # Verwende SDK-Namen ohne @-Präfix für einfache Suchen
    bare = sdk_name.lstrip("@").replace("/", "/")
    queries = [
        f'require("{sdk_name}")',
        f"require('{sdk_name}')",
        f'from "{sdk_name}"',
        f"from '{sdk_name}'",
    ]
elif ecosystem == "python":
    queries = [
        f"import {sdk_name}",
        f"from {sdk_name} import",
        f"from {sdk_name}.",
    ]
elif ecosystem == "go":
    queries = [f'"{sdk_name}"']
else:
    queries = [sdk_name]

print(f"Erstelle Abfragen für {sdk_name} ({ecosystem}):")
for q in queries:
    print(f"  {q}")

seen_repos = {}  # full_name -> first match
search_rate_remaining = 30
flags = []

for i, query in enumerate(queries):
    if search_rate_remaining <= 2:
        flags.append(f"Code-Suchrate niedrig ({search_rate_remaining}) – restliche Muster übersprungen")
        print(f"  Rate-Limit niedrig ({search_rate_remaining}), vorzeitiger Stopp")
        break

    url = f"https://api.github.com/search/code?q={urllib.parse.quote(query)}&per_page=100"
    req = urllib.request.Request(url, headers=headers)

    try:
        with urllib.request.urlopen(req, timeout=20, context=ctx) as resp:
            search_rate_remaining = int(resp.headers.get("X-RateLimit-Remaining", 10))
            raw = json.loads(resp.read())

        items = raw.get("items", [])
        total = raw.get("total_count", 0)
        print(f"  Muster '{query}': {total} insgesamt, {len(items)} abgerufen | rate_remaining={search_rate_remaining}")

        for item in items:
            repo = item.get("repository", {})
            full_name = repo.get("full_name", "")
            if full_name and full_name not in seen_repos:
                seen_repos[full_name] = {
                    "full_name": full_name,
                    "name": repo.get("name", ""),
                    "owner_login": repo.get("owner", {}).get("login", ""),
                    "owner_type": repo.get("owner", {}).get("type", ""),
                    "file_path": item.get("path", ""),
                    "matched_pattern": query,
                    "html_url": repo.get("html_url", ""),
                    "description": repo.get("description") or "",
                }

    except urllib.error.HTTPError as e:
        if e.code == 403:
            flags.append(f"Code-Suchrate-Limit beim Muster '{query}' erreicht")
            print(f"  Rate-Limit (403) bei '{query}' erreicht")
            break
        else:
            print(f"  HTTP {e.code} bei '{query}'")
    except Exception as e:
        print(f"  Fehler bei '{query}': {e}")

    # 10 Anfragen/Minute Code-Suche-Limit beachten
    if i < len(queries) - 1:
        time.sleep(6)

results = list(seen_repos.values())
json.dump(results, open("/tmp/sat-raw-results.json", "w"), indent=2)
print(f"\nInsgesamt gefundene eindeutige Repos: {len(results)}")
if flags:
    print("Flags:", flags)

import urllib.parse  # ensure imported
PYEOF

Wenn 0 Ergebnisse: Sage dem Benutzer: "Keine Repos gefunden, die {sdk_name} importieren. Der GitHub-Code-Suchindex benötigt 1-4 Wochen für neue Pakete. Wenn das SDK etabliert ist, überprüfe die Importmuster in references/import-patterns.md."

---

Schritt 4: Repos bewerten und klassifizieren

Kein API-Aufruf. Reines Python. Filtere Rauschen, berechne den Adoptionsscore, klassifiziere jedes Repo.

python3 << 'PYEOF'
import json
from datetime import datetime, timezone

data = json.load(open("/tmp/sat-input.json"))
exclude_owner = data.get("exclude_owner", "").lower()
sdk_name = data["sdk_name"].lower().split("/")[-1].replace("@", "")

results = json.load(open("/tmp/sat-raw-results.json"))

TUTORIAL_WORDS = {"example", "tutorial", "demo", "learn", "sample", "starter",
                  "boilerplate", "template", "playground", "test", "course", "workshop"}

scored = []
now = datetime.now(tz=timezone.utc)

for repo in results:
    full_name = repo["full_name"]
    owner_login = repo.get("owner_login", "").lower()
    repo_name = repo.get("name", "").lower()
    description = (repo.get("description") or "").lower()
    owner_type = repo.get("owner_type", "User")

    # Eigene Repos des SDK-Besitzers ausschließen
    if exclude_owner and owner_login == exclude_owner.lower():
        continue

    # Tutorial-Rauschen erkennen
    name_words = set(repo_name.replace("-", " ").replace("_", " ").split())
    desc_words = set(description.split())
    is_tutorial = bool((name_words | desc_words) & TUTORIAL_WORDS)
    # Auch ausschließen, wenn der Repo-Name dem SDK-Namen entspricht (wahrscheinlich ein Fork)
    if repo_name == sdk_name or repo_name.startswith(sdk_name + "-"):
        is_tutorial = True  # als Rauschen behandeln

    # Klassifizierungsstufe
    if is_tutorial:
        tier = "tutorial_noise"
    elif owner_type == "Organization":
        tier = "company_org"
    else:
        tier = "solo_dev"  # wird in Schritt 5 zu affiliated_dev hochgestuft, wenn das Firmenfeld ausgefüllt ist

    # Adoptionsscore (jetzt mit Teildaten befüllt, in Schritt 5 angereichert)
    score = 0
    if owner_type == "Organization": score += 50
    if not is_tutorial:              score += 20
    # Sterne, Tage seit Push, is_fork, is_archived werden in Schritt 5 hinzugefügt

    scored.append({
        **repo,
        "tier": tier,
        "is_tutorial": is_tutorial,
        "adoption_score": score,
        "enriched": False
    })

# Sortieren: company_org zuerst, dann nach Stufe
tier_order = {"company_org": 0, "affiliated_dev": 1, "solo_dev": 2, "tutorial_noise": 3}
scored.sort(key=lambda x: (tier_order.get(x["tier"], 9), -x["adoption_score"]))

json.dump(scored, open("/tmp/sat-scored.json", "w"), indent=2)

tiers = {}
for r in scored:
    tiers[r["tier"]] = tiers.get(r["tier"], 0) + 1

print(f"Klassifizierung:")
for tier, count in sorted(tiers.items(), key=lambda x: tier_order.get(x[0], 9)):
    print(f"  {tier}: {count}")
print(f"Insgesamt: {len(scored)} Repos")

non_noise = [r for r in scored if r["tier"] != "tutorial_noise"]
print(f"\nTop-Repos für Anreicherung (nicht-Rauschen): {len(non_noise)}")
for r in non_noise[:5]:
    print(f"  {r['full_name']} ({r['tier']}) -- {r.get('description','')[:60]}")
PYEOF

Wenn alle Repos tutorial_noise sind: Stoppe. Sage dem Benutzer: "Alle gefundenen Repos scheinen Tutorials oder Beispiele zu sein. In öffentlichem GitHub wurden keine Produktionsadoptoren erkannt. Das SDK ist möglicherweise zu neu, oder der Paketname ist so generisch, dass die Suchergebnisse von Beispielen dominiert werden."

---

Schritt 5: Repos mit starkem Signal anreichern

Rufe vollständige Repo-Metadaten, Besitzerprofil und Top-Beitragende für Nicht-Rauschen-Repos ab. Überspringe tutorial_noise-Repos vollständig.

python3 << 'PYEOF'
import json, urllib.request, ssl, os, time
from datetime import datetime, timezone

ctx = ssl._create_unverified_context()
token = os.environ["GITHUB_TOKEN"]
headers = {
    "Accept": "application/vnd.github+json",
    "Authorization": f"Bearer {token}",
    "User-Agent": "sdk-adoption-tracker/1.0"
}

scored = json.load(open("/tmp/sat-scored.json"))
core_remaining = 5000
flags = []

def gh_get(path):
    global core_remaining
    req = urllib.request.Request(f"https://api.github.com{path}", headers=headers)
    try:
        with urllib.request.urlopen(req, timeout=15, context=ctx) as resp:
            remaining = resp.headers.get("X-RateLimit-Remaining")
            if remaining:
                core_remaining = int(remaining)
            return json.loads(resp.read())
    except urllib.error.HTTPError as e:
        if e.code == 404:
            return None
        raise
    except Exception:
        return None

target = [r for r in scored if r["tier"] != "tutorial_noise"]
print(f"Reichere {len(target)} Repos an (überspringe tutorial_noise)...")

enriched = []

for item in target:
    full_name = item["full_name"]
    owner_login = item["owner_login"]
    owner_type = item["owner_type"]

    # Repo-Metadaten abrufen
    repo_data = gh_get(f"/repos/{full_name}")
    if not repo_data:
        flags.append(f"Repo {full_name}: Metadaten konnten nicht abgerufen werden (404)")
        continue

    # Eigentümerdetails abrufen
    owner_data = gh_get(f"/users/{owner_login}")
    owner_company = (owner_data.get("company") or "").strip() if owner_data else ""
    owner_name = (owner_data.get("name") or "").strip() if owner_data else ""

    # Wenn user ein Organisation ist, hole Organisationsdetails
    org_name = ""
    if owner_type == "Organization":
        org_data = gh_get(f"/orgs/{owner_login}")
        if org_data:
            org_name = (org_data.get("name") or owner_login).strip()

    # Firmenname ermitteln (priorisiere Organisationsname, dann Company-Feld)
    if owner_type == "Organization":
        company_name = org_name or owner_name
    else:
        company_name = owner_company or owner_name

    # Top-Contributors abrufen (max 5)
    contributors = gh_get(f"/repos/{full_name}/contributors?per_page=5")
    contrib_handles = []
    if isinstance(contributors, list):
        for c in contributors:
            login = c.get("login", "")
            if login and login != owner_login:
                contrib_handles.append(login)
            if len(contrib_handles) >= 3:
                break

    # Repo-Details extrahieren
    stars = repo_data.get("stargazers_count", 0)
    pushed_at_str = repo_data.get("pushed_at", "")
    is_fork = repo_data.get("fork", False)
    is_archived = repo_data.get("archived", False)
    is_empty = repo_data.get("size", 0) == 0  # approximativ

    # Tage seit letztem Push
    if pushed_at_str:
        pushed_dt = datetime.fromisoformat(pushed_at_str.replace("Z", "+00:00"))
        days_since_push = (now - pushed_dt).days
    else:
        days_since_push = 999

    # Adoptionsscore neu berechnen
    score = 0
    if owner_type == "Organization": score += 50
    if not is_tutorial:              score += 20
    score += min(stars, 100)
    if days_since_push < 90:         score += 30
    elif days_since_push < 365:      score += 10
    if is_fork:                      score -= 30
    if is_archived:                  score -= 50
    if item.get("is_tutorial"):     score -= 100
    score = max(0, score)

    enriched.append({
        **item,
        "stars": stars,
        "days_since_push": days_since_push,
        "is_fork": is_fork,
        "is_archived": is_archived,
        "company_name": company_name if company_name else "nicht angegeben",
        "owner_name": owner_name if owner_name else "nicht angegeben",
        "contributor_logins": contrib_handles,
        "adoption_score": score,
        "enriched": True
    })

    time.sleep(0.1)

# Nicht-angereicherte Rauschen-Repos beibehalten (mit Mindestdaten)
for item in scored:
    if item["tier"] == "tutorial_noise":
        enriched.append({
            **item,
            "stars": 0,
            "days_since_push": 999,
            "is_fork": False,
            "is_archived": False,
            "company_name": "nicht angegeben",
            "owner_name": item.get("owner_login", "nicht angegeben"),
            "contributor_logins": [],
            "adoption_score": 0,
            "enriched": False
        })

# Nach Score sortieren (absteigend), Rauschen ans Ende
tier_order = {"company_org": 0, "affiliated_dev": 1, "solo_dev": 2, "tutorial_noise": 3}
enriched.sort(key=lambda x: (tier_order.get(x["tier"], 9), -x["adoption_score"]))

json.dump(enriched, open("/tmp/sat-enriched.json", "w"), indent=2)

print(f"\nAnreicherung abgeschlossen: {len([e for e in enriched if e['enriched']])} angereichert")
print(f"Insgesamt: {len(enriched)} Repos")

non_noise = [e for e in enriched if e["tier"] != "tutorial_noise"]
print(f"\nTop-High-Signal-Repos:")
for e in non_noise[:10]:
    print(f"  {e['full_name']} (Score: {e['adoption_score']}, Firma: {e['company_name'][:30]})")

if flags:
    print("\nFlags:")
    for f in flags:
        print(f"  {f}")
PYEOF

---

Schritt 6: KI-Analyse der Top-Repos

Präsentiere der KI die 20 wichtigsten Nicht-Rauschen-Repos zur Analyse.

python3 << 'PYEOF'
import json

data = json.load(open("/tmp/sat-enriched.json"))

non_noise = [r for r in data if r["tier"] != "tutorial_noise"]
top20 = non_noise[:20]

print(json.dumps(top20, indent=2))
PYEOF

Anweisungen für die KI-Analyse:

Analysiere die obigen 20 Repos. Für jedes Repo:

1. Bestätige die Klassifizierung – Ist tier korrekt? (company_org wenn Besitzer eine Organisation ist, solo_dev wenn ein einzelner GitHub-Benutzer, affiliated_dev wenn ein Benutzer, der einem Unternehmen zugeordnet werden kann)
2. Bewerte das Adoptionssignal: Handelt es sich um eine echte Produktionsnutzung? (z.B. verwendete Technologie, Aktivitätsniveau, GPU-Fernbedienung für LLM-Bibliotheken, Zahlungsabwicklung für ein API-SDK)
3. Schlage einen Vertriebskontakt vor: Wenn es sich um einen Unternehmens-Adopter handelt, notiere einen Kontaktvorschlag basierend auf den bereitgestellten Metadaten.

Gib die Analyse im folgenden Format aus:

{
  "analysis": [
    {
      "full_name": "org/repo",
      "tier": "company_org",
      "adoption_confidence": "high/medium/low",
      "adoption_evidence": "kurze Begründung",
      "outreach_context": "Notizen für Vertriebskontaktaufnahme"
    }
  ],
  "rejected_repos": ["full_name"],
  "flags": ["alle Probleme"],
  "top_adopter": {
    "company": "Firmenname",
    "repo": "org/repo",
    "score": 95,
    "reason": "Warum dieser Adopter am wichtigsten ist"
  }
}

---

Schritt 7: Abschlussbericht generieren

Kombiniere KI-Analyse aus Schritt 6 mit den vollständigen angereicherten Daten aus Schritt 5, um einen zusammenfassenden Bericht zu erstellen.

python3 << 'PYEOF'
import json, sys

# Wenn KI-Analyse als JSON-Datei gespeichert, lade sie
# Andernfalls füge die Analyse aus der Konversation ein

with open("/tmp/sat-enriched.json") as f:
    enriched = json.load(f)

# Beispiel: Füge KI-Analyse hier ein
# ki_analyse = json.loads(input("KI-Analyse-JSON einfügen: "))
ki_analyse = json.load(open("/tmp/sat-ki-analyse.json")) if False else None

# Generiere Bericht
report_lines = []
report_lines.append("# SDK-Adoptionsbericht")
report_lines.append("")
report_lines.append(f"**Generiert:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}")
report_lines.append(f"**SDK:** {sdk_name}")
report_lines.append(f"**Ökosystem:** {ecosystem}")
report_lines.append("")

# Zusammenfassung
company_orgs = [r for r in enriched if r["tier"] == "company_org"]
solo_devs = [r for r in enriched if r["tier"] in ("solo_dev", "affiliated_dev")]
tutorials = [r for r in enriched if r["tier"] == "tutorial_noise"]

report_lines.append(f"## Zusammenfassung")
report_lines.append(f"- **Unternehmensorganisationen:** {len(company_orgs)}")
report_lines.append(f"- **Einzelentwickler:** {len(solo_devs)}")
report_lines.append(f"- **Tutorials/Rauschen:** {len(tutorials)}")
report_lines.append(f"- **Gesamt gefundene Repos:** {len(enriched)}")
report_lines.append("")
report_lines.append("## Top-Adopter (nach Signalstärke)")
report_lines.append("")
report_lines.append("| Rang | Repo | Typ | Score | Firma | Sterne | Letzter Push |")
report_lines.append("|------|------|-----|-------|-------|--------|--------------|")

for i, r in enumerate(enriched[:20], 1):
    if r["tier"] == "tutorial_noise":
        break
    tier_emoji = {"company_org": "🏢", "affiliated_dev": "👤", "solo_dev": "👤"}
    emoji = tier_emoji.get(r["tier"], "")
    report_lines.append(
        f"| {i} | {r['full_name']} | {emoji} {r['tier']} | {r['adoption_score']} | "
        f"{r['company_name']} | {r.get('stars', 0)} | {r.get('days_since_push', '?')} Tage |"
    )

report_lines.append("")
report_lines.append("## Neue Adoptoren (erkannt anhand Alter der Aktivität)")
report_lines.append("")
# Sortiere nach jüngstem Push (innerhalb der letzten 90 Tage)
recent = [r for r in enriched if r["tier"] != "tutorial_noise" and r.get("days_since_push", 999) < 90]
recent.sort(key=lambda x: x.get("days_since_push", 999))

for r in recent[:10]:
    report_lines.append(f"- **{r['full_name']}** – {r['company_name']} – letzter Push vor {r['days_since_push']} Tagen")

report_lines.append("")
report_lines.append("## Vertriebskontext (Unternehmensadopter)")
report_lines.append("")
for r in company_orgs:
    report_lines.append(f"### {r['company_name']}")
    report_lines.append(f"- **Repo:** {r['full_name']}")
    report_lines.append(f"- **Score:** {r['adoption_score']}")
    report_lines.append(f"- **Sterne:** {r.get('stars', 0)}")
    report_lines.append(f"- **Letzter Push:** {r.get('days_since_push', '?')} Tage her")
    report_lines.append(f"- **Besitzer:** {r.get('owner_name', 'nicht angegeben')}")
    if r.get("contributor_logins"):
        report_lines.append(f"- **Beitragende:** {', '.join(r['contributor_logins'][:3])}")
    report_lines.append("")

report_lines.append("---")
report_lines.append("*Bericht generiert vom SDK-Adoption-Tracker*")

print("\n".join(report_lines))
PYEOF

---

Schritt 8: Abschluss

Präsentiere den vollständigen Bericht dem Benutzer. Biete an:

• Ergebnis als JSON exportieren
• Ergebnis als CSV exportieren
• Alle angereicherten Daten anzeigen
• Den Vorgang mit einem anderen SDK oder einer anderen Konfiguration wiederholen