npm 다운로드를 리드로 전환

npm 다운로드를 리드로 전환은(는) 무엇을 하나요?

npm 패키지 목록을 입력받아 12주간의 다운로드 데이터를 가져옵니다. 폭발적 성장 속도를 계산합니다. 유지관리자 프로필을 보강합니다. 연락처 신호와 아웃리치 메시지가 포함된, 순위별 리드 브리프를 'breakout' 패키지마다 출력합니다.

---

중요 규칙: 출력의 모든 패키지 다운로드 수치는 npm API 응답에서 가져와야 합니다. 모든 유지관리자 GitHub 핸들 또는 트위터 사용자 이름은 GitHub API 응답에서 가져와야 하며, npm 사용자 이름에서 추측해서는 안 됩니다. GitHub API가 twitter_username 필드를 반환하지 않은 경우 "not found on GitHub"라고 작성하고, 임의로 만들어서는 안 됩니다.

---

일반적인 실수

에이전트가 하려는 행동	잘못된 이유
목록의 모든 패키지에 대해 GitHub 프로필을 가져옴	토큰이 없으면 시간당 60회 요청 제한. 정체되거나 하락하는 패키지를 보강하면 'breakout' 패키지에 도달하기 전에 예산을 소진함. 'breakout' 및 'watching' 패키지에 대해서만 프로필을 가져와야 함.
원시 주간 다운로드 수로 패키지 순위를 매김	원시 다운로드는 React나 lodash를 선호하게 되어 리드 후보가 아님. 주간 1K에서 8K로 증가하는 패키지가 React의 주간 50M보다 더 실행 가능함. 'velocity score'가 신호임.
스코프 패키지의 URL 인코딩을 건너뜀	@org/pkg를 인코딩하지 않으면 npm API에서 404 오류 발생. 모든 스코프 패키지 이름에 대해 @를 %40으로, /를 %2F로 인코딩해야 함.
GitHub 속도 제한에 도달하면 스킬을 중단함	정상적으로 성능을 저하시킴. npm 데이터에서 'velocity' 리더보드를 제시하고, 나머지 GitHub 보강은 건너뛰며, data_quality_flags에 플래그를 추가함. 중단하지 말 것.
특정 패키지를 언급하지 않고 아웃리치 메시지를 작성함	일반적인 "귀하의 프로젝트를 보았습니다" 메시지는 답장을 받지 못함. 모든 아웃리치 메시지는 패키지 이름, 성장 수치, 사용자가 제공한 컨텍스트와의 구체적인 연관성을 명시해야 함.
주간 다운로드가 500 미만인 패키지를 리드로 포함함	주간 500 미만은 노이즈임. 유지관리자는 아직 의미 있는 청중을 보유하지 못함. "too early"로 표시하되 리드로 제시하지 말 것.

---

1단계: 설정 확인

echo "GITHUB_TOKEN: ${GITHUB_TOKEN:-not set, unauthenticated rate limit applies (60 req/hr -- enough for ~10 packages)}"

GITHUB_TOKEN이 설정되지 않은 경우: 계속 진행합니다. 사용자에게 알립니다: "GITHUB_TOKEN이 설정되지 않았습니다. GitHub 보강은 속도 제한에 도달하기 전까지 약 10개의 패키지로 제한됩니다. github.com/settings/tokens에서 토큰을 추가하세요 (범위 필요 없음)."

필수 키는 없습니다. npm API와 npm 레지스트리는 완전히 공개되어 있으며 인증이 필요 없습니다.

---

2단계: 입력 수집

대화에서 다음을 수집합니다:

• 하나 이상의 npm 패키지 이름 (스코프되지 않은 esbuild 또는 스코프된 @hono/hono)
• 선택 사항: 짧은 제품 컨텍스트 문자열 (아웃리치 메시지를 개인화하는 데 사용됨)

사용자가 npmjs.com URL을 제공하는 경우 패키지 이름만 추출합니다. @와 조직 접두사를 포함한 전체 스코프 이름을 보존합니다. 인코딩은 3단계에서 처리됩니다.

패키지가 제공되지 않은 경우: 질문: "분석할 npm 패키지를 알려주세요. 자사 패키지, 경쟁사 패키지, 또는 혼합해서 제공할 수 있습니다. 예시: esbuild, @hono/hono, zod, valibot"

python3 << 'PYEOF'
import json, sys

packages_raw = "PACKAGES_HERE"  # 쉼표 또는 줄바꿈으로 구분
product_context = "CONTEXT_HERE"  # 선택 사항, 빈 문자열 가능

packages = [p.strip() for p in packages_raw.replace("\n", ",").split(",") if p.strip()]
if not packages:
    print("ERROR: No packages provided.")
    sys.exit(1)

print(f"Packages to analyze: {len(packages)}")
for p in packages:
    print(f"  {p}")

with open("/tmp/npl-input.json", "w") as f:
    json.dump({"packages": packages, "product_context": product_context}, f)
PYEOF

---

3단계: 12주 다운로드 데이터 가져오기

독립 스크립트를 사용할 수 있다면 사용하세요. 3, 4, 5단계를 한 번에 처리하므로 아래 인라인 코드 블록을 실행할 필요가 없습니다.

# 스크립트가 있는지 확인
ls scripts/fetch.py 2>/dev/null && echo "script available" || echo "script not found"

스크립트를 사용할 수 있는 경우, 직접 실행하고 6단계로 건너뜁니다:

python3 scripts/fetch.py PACKAGES_HERE --context "CONTEXT_HERE" --output /tmp/npl-script-out.json

그런 다음 출력을 6단계에서 예상하는 보강된 형식으로 로드합니다:

python3 << 'PYEOF'
import json

out = json.load(open("/tmp/npl-script-out.json"))
# 스크립트 출력에는 results 배열이 있습니다 -- 6-8단계를 위해 scored와 enriched로 분할
enriched = [r for r in out["results"] if "profile" in r]
scored = out["results"]
json.dump(scored, open("/tmp/npl-scored.json", "w"), indent=2)
json.dump(enriched, open("/tmp/npl-enriched.json", "w"), indent=2)
json.dump({"packages": [r["package"] for r in scored], "product_context": out.get("product_context", "")},
          open("/tmp/npl-input.json", "w"), indent=2)
print(f"Loaded {len(scored)} packages | {out['breakout_count']} breakout | {out['watching_count']} watching")
PYEOF

스크립트를 사용할 수 없는 경우, 아래 인라인 코드를 실행합니다.

npm 다운로드 API에서 각 패키지의 일일 다운로드 데이터를 가져옵니다. 주간 버킷으로 집계합니다.

python3 << 'PYEOF'
import json, urllib.request, sys, time
from datetime import datetime, timedelta, timezone
from collections import defaultdict
import urllib.parse

data = json.load(open("/tmp/npl-input.json"))
packages = data["packages"]

end_date = datetime.now(tz=timezone.utc)
start_date = end_date - timedelta(weeks=13)  # 부분 주를 위한 추가 완충 주
start_str = start_date.strftime("%Y-%m-%d")
end_str = end_date.strftime("%Y-%m-%d")

results = []
failed = []

for pkg in packages:
    # URL 인코딩: @ -> %40, / -> %2F
    encoded = pkg.replace("@", "%40").replace("/", "%2F")
    url = f"https://api.npmjs.org/downloads/range/{start_str}:{end_str}/{encoded}"

    try:
        req = urllib.request.Request(url, headers={"User-Agent": "npm-downloads-to-leads/1.0"})
        with urllib.request.urlopen(req, timeout=20) as resp:
            raw = json.loads(resp.read())

        # ISO 주별로 일일 데이터를 주간으로 집계
        weekly = defaultdict(int)
        for entry in raw.get("downloads", []):
            day = datetime.strptime(entry["day"], "%Y-%m-%d")
            week_key = day.isocalendar()[:2]  # (year, week_num)
            weekly[week_key] += entry["downloads"]

        weeks = [v for k, v in sorted(weekly.items())]
        # 마지막 12개의 완전한 주간 버킷을 사용
        weeks = weeks[-12:]

        results.append({
            "package": pkg,
            "weeks": weeks,
            "total_weeks": len(weeks),
            "current_weekly": weeks[-1] if weeks else 0,
            "status": "ok"
        })
        print(f"  {pkg}: {len(weeks)} weeks, latest week {weeks[-1]:,} downloads")

    except urllib.error.HTTPError as e:
        if e.code == 404:
            failed.append(pkg)
            results.append({"package": pkg, "weeks": [], "total_weeks": 0, "current_weekly": 0, "status": "not_found"})
            print(f"  {pkg}: NOT FOUND (404) -- will be skipped")
        else:
            failed.append(pkg)
            results.append({"package": pkg, "weeks": [], "total_weeks": 0, "current_weekly": 0, "status": f"error_{e.code}"})
            print(f"  {pkg}: HTTP {e.code} error")
    except Exception as e:
        failed.append(pkg)
        results.append({"package": pkg, "weeks": [], "total_weeks": 0, "current_weekly": 0, "status": f"error"})
        print(f"  {pkg}: fetch failed ({e})")

    time.sleep(0.2)  # 완만한 속도 제한

json.dump(results, open("/tmp/npl-download-data.json", "w"), indent=2)
print(f"\nFetch complete. OK: {len(results) - len(failed)} | Failed/Not found: {len(failed)}")
if failed:
    print(f"Skipped: {', '.join(failed)}")
PYEOF

모든 패키지가 404 또는 오류를 반환하는 경우: 중단합니다. 사용자에게 알립니다: "다운로드 데이터를 가져올 수 없습니다. 패키지 이름이 올바르고 npmjs.com에 존재하는지 확인하십시오. 스코프 패키지는 전체 이름을 포함해야 합니다: @org/package"

---

4단계: Velocity 점수 계산

API 호출 없음. 순수 Python. velocity 점수, 성장률을 계산하고 각 패키지를 분류합니다.

python3 << 'PYEOF'
import json

raw_results = json.load(open("/tmp/npl-download-data.json"))
scored = []

for item in raw_results:
    pkg = item["package"]
    weeks = item["weeks"]
    status = item["status"]

    if status != "ok" or len(weeks) < 4:
        scored.append({**item, "velocity_score": 0, "growth_pct": 0, "tier": "insufficient_data",
                       "recent_4_avg": 0, "prior_4_avg": 0})
        continue

    recent_4 = sum(weeks[-4:]) / 4
    prior_4 = sum(weeks[-8:-4]) / max(len(weeks) - 4, 1) if len(weeks) >= 8 else sum(weeks[:4]) / max(len(weeks[:4]), 1)
    recent_2 = sum(weeks[-2:]) / 2
    mid_2 = sum(weeks[-4:-2]) / 2 if len(weeks) >= 4 else recent_2

    growth_ratio = recent_4 / max(prior_4, 1)
    acceleration = recent_2 / max(mid_2, 1)
    growth_pct = round((growth_ratio - 1) * 100, 1)

    # 적정 규모 승수: 주간 500-500K 다운로드
    if recent_4 < 500:
        noise_factor = max(recent_4 / 500, 0.1)
    elif recent_4 > 500_000:
        noise_factor = max(500_000 / recent_4, 0.1)
    else:
        noise_factor = 1.0

    velocity_score = round(growth_ratio * acceleration * noise_factor * 100, 1)

    # 분류
    if velocity_score > 80 and 500 < recent_4 < 500_000 and growth_ratio >= 1.5:
        tier = "breakout"
    elif velocity_score > 40 and recent_4 >= 500 and growth_ratio >= 1.2:
        tier = "watching"
    elif recent_4 < 500:
        tier = "too_early"
    elif recent_4 >= 500_000:
        tier = "established"
    else:
        tier = "steady"

    scored.append({
        **item,
        "velocity_score": velocity_score,
        "growth_pct": growth_pct,
        "recent_4_avg": round(recent_4),
        "prior_4_avg": round(prior_4),
        "tier": tier
    })

# velocity_score 내림차순 정렬
scored.sort(key=lambda x: x["velocity_score"], reverse=True)

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

breakout = [p for p in scored if p["tier"] == "breakout"]
watching = [p for p in scored if p["tier"] == "watching"]
too_early = [p for p in scored if p["tier"] == "too_early"]

print(f"Velocity scoring complete:")
print(f"  BREAKOUT: {len(breakout)}")
print(f"  WATCHING: {len(watching)}")
print(f"  STEADY/ESTABLISHED: {len([p for p in scored if p['tier'] in ('steady','established')])}")
print(f"  TOO EARLY (<500/week): {len(too_early)}")
print()
for p in scored[:10]:
    print(f"  {p['tier'].upper():12} {p['package']:30} score={p['velocity_score']:6.1f}  "
          f"{p['recent_4_avg']:>8,}/wk  growth={p['growth_pct']:+.0f}%")

# 분석할 가치가 있는 것이 없으면 중단
if not breakout and not watching:
    all_too_early = all(p["tier"] in ("too_early", "insufficient_data") for p in scored)
    if all_too_early:
        print("\nERROR: All packages are below the 500 weekly downloads threshold for reliable velocity analysis.")
        print("Try packages with more community adoption.")
        import sys; sys.exit(1)
PYEOF

모든 패키지가 주간 500 미만인 경우: 위 메시지와 함께 중단합니다.

---

5단계: 유지관리자 프로필 가져오기

'breakout' 및 'watching' 패키지에 대해서만 수행합니다. npm 레지스트리 메타데이터를 가져온 다음 GitHub 사용자 프로필을 가져옵니다.

python3 << 'PYEOF'
import json, urllib.request, re, os, time

scored = json.load(open("/tmp/npl-scored.json"))
token = os.environ.get("GITHUB_TOKEN", "")

gh_headers = {"Accept": "application/vnd.github+json", "User-Agent": "npm-downloads-to-leads/1.0"}
if token:
    gh_headers["Authorization"] = f"Bearer {token}"

# breakout 및 watching 패키지만 처리
target_packages = [p for p in scored if p["tier"] in ("breakout", "watching")]
print(f"Fetching profiles for {len(target_packages)} packages (breakout + watching)...")

gh_rate_remaining = 999
enriched = []

for item in target_packages:
    pkg = item["package"]
    profile = {"package": pkg, "npm_maintainers": [], "description": "", "keywords": [],
               "github_owner": None, "github_repo": None, "github_users": [], "npm_homepage": ""}

    # --- npm 레지스트리 ---
    encoded = pkg.replace("@", "%40").replace("/", "%2F")
    reg_url = f"https://registry.npmjs.org/{encoded}"
    try:
        req = urllib.request.Request(reg_url, headers={"User-Agent": "npm-downloads-to-leads/1.0"})
        with urllib.request.urlopen(req, timeout=20) as resp:
            reg = json.loads(resp.read())

        profile["description"] = reg.get("description", "")
        profile["keywords"] = (reg.get("keywords") or [])[:6]
        profile["npm_homepage"] = reg.get("homepage", "")
        profile["npm_maintainers"] = [m.get("name", "") for m in reg.get("maintainers", []) if m.get("name")]

        # 저장소 URL에서 GitHub 소유자 추출
        repo_field = reg.get("repository") or {}
        if isinstance(repo_field, dict):
            repo_url = repo_field.get("url", "")
        else:
            repo_url = str(repo_field)
        gh_match = re.search(r"github\.com[/:]([^/]+)/([^/.]+)", repo_url)
        if gh_match:
            profile["github_owner"] = gh_match.group(1)
            profile["github_repo"] = gh_match.group(2).rstrip(".git")

        print(f"  {pkg}: registry OK | maintainers={profile['npm_maintainers'][:3]} | "
              f"github_owner={profile['github_owner']}")
    except Exception as e:
        print(f"  {pkg}: registry fetch failed ({e})")

    time.sleep(0.1)

    # --- GitHub 사용자 프로필 ---
    candidates = []
    if profile["github_owner"]:
        candidates.append(profile["github_owner"])
    # npm 유지관리자 사용자 이름도 시도 (종종 GitHub와 일치)
    for m in profile["npm_maintainers"][:2]:
        if m and m not in candidates:
            candidates.append(m)

    for username in candidates[:3]:
        if gh_rate_remaining <= 5:
            print(f"  GitHub rate limit low ({gh_rate_remaining} remaining) -- skipping {username}")
            break

        gh_url = f"https://api.github.com/users/{username}"
        req = urllib.request.Request(gh_url, headers=gh_headers)
        try:
            with urllib.request.urlopen(req, timeout=15) as resp:
                gh_rate_remaining = int(resp.headers.get("X-RateLimit-Remaining", "0"))
                gh_data = json.loads(resp.read())

            user_entry = {
                "github_username": gh_data.get("login", ""),
                "name": gh_data.get("name", ""),
                "twitter_username": gh_data.get("twitter_username", ""),
                "blog": gh_data.get("blog", ""),
                "bio": (gh_data.get("bio") or "")[:150],
                "public_repos": gh_data.get("public_repos", 0),
                "followers": gh_data.get("followers", 0)
            }
            profile["github_users"].append(user_entry)
            print(f"      github user {username}: name={user_entry['name']} | twitter={user_entry['twitter_username']}")
        except urllib.error.HTTPError as e:
            if e.code == 404:
                print(f"      github user {username}: 404 (not found)")
            else:
                print(f"      github user {username}: HTTP {e.code}")
                gh_rate_remaining = 0
        except Exception as e:
            print(f"      github user {username}: failed ({e})")

        time.sleep(0.15)

    enriched.append({**item, "profile": profile})

json.dump(enriched, open("/tmp/npl-enriched.json", "w"), indent=2)
print(f"\nProfile enrichment complete. Enriched {len(enriched)} packages.")
PYEOF

---

6단계: 리드 브리프 생성

마크다운 형식의 리드 브리프를 생성합니다. 'breakout' 패키지를 먼저 나열하고, 그 다음 'watching' 패키지를 나열하며 각 패키지에 대한 섹션을 만듭니다. 엔드 투 엔드 파이프라인은 각 패키지에 대해 다음을 포함하는 단일 보고서를 생성해야 합니다:

1. 패키지 헤더: 이름(esbuild), velocity 점수(152.3), 4주 추세("+240%"), 계층("BREAKOUT")
2. 성장 데이터: 최근 4주 평균 다운로드, 이전 4주 평균, 도표 없이 "추세: 급상승" 같은 간단한 텍스트 추세 설명
3. 프로필 데이터: 패키지 설명, 키워드, 패키지 홈페이지 URL
4. 유지관리자: npm 사용자 이름과 GitHub 사용자 정보 (포함된 경우) - GitHub가 트위터를 반환하지 않으면 추측하지 말 것
5. 아웃리치 메시지: 제공된 제품 컨텍스트를 사용하여 유지관리자가 귀하의 제품에 관심을 가질 만한 이유를 설명하는 3-4문장 초안. 구체적으로 언급하십시오: 패키지 이름, 성장 지표, 그리고 유지관리자의 작업이 귀하의 제품과 어떻게 연결되는지.
6. 데이터 품질 플래그: (만약 있다면) GitHub 속도 제한, 불완전한 프로필 등에 대한 참고 사항

python3 << 'PYEOF'
import json

scored = json.load(open("/tmp/npl-scored.json"))
enriched = json.load(open("/tmp/npl-enriched.json"))

# 빠른 조회를 위해 보강된 패키지를 사전으로 변환
enriched_map = {e["package"]: e.get("profile", {}) for e in enriched}

product_context = json.load(open("/tmp/npl-input.json")).get("product_context", "")

report = []
report.append("# npm Downloads to Leads Report\n")
if product_context:
    report.append(f"**Context:** {product_context}\n")

# 먼저 breakout, 그 다음 watching
for item in scored:
    if item["tier"] not in ("breakout", "watching"):
        continue

    pkg = item["package"]
    prof = enriched_map.get(pkg, {})
    maintainers = prof.get("npm_maintainers", [])
    gh_users = prof.get("github_users", [])

    tier_label = "BREAKOUT" if item["tier"] == "breakout" else "WATCHING"

    report.append(f"\n---\n## {pkg} ({tier_label})\n")

    # 1. 패키지 헤더
    report.append(f"**Velocity Score:** {item['velocity_score']} | "
                  f"**Growth:** {item['growth_pct']:+.0f}% | "
                  f"**Recent 4-wk Avg:** {item['recent_4_avg']:,}/wk\n")

    # 2. 성장 데이터
    trend = "급상승" if item["tier"] == "breakout" else "성장 중"
    report.append(f"**Trend:** {trend} (velocity: {item['velocity_score']}, previous avg: {item['prior_4_avg']:,}/wk → current avg: {item['recent_4_avg']:,}/wk)\n")

    # 3. 프로필 데이터
    desc = prof.get("description", "") or item.get("description", "")
    if desc:
        report.append(f"**Description:** {desc}\n")
    keywords = prof.get("keywords", [])
    if keywords:
        report.append(f"**Keywords:** {', '.join(keywords[:6])}\n")
    homepage = prof.get("npm_homepage", "")
    if homepage:
        report.append(f"**Homepage:** {homepage}\n")

    # 4. 유지관리자
    if maintainers:
        report.append(f"**npm Maintainers:** {', '.join(maintainers[:5])}\n")
    if gh_users:
        for u in gh_users:
            gh_handle = u.get("github_username", "")
            name = u.get("name", "") or gh_handle
            twitter = u.get("twitter_username", "")
            tw_part = f"Twitter: @{twitter}" if twitter else "Twitter: not found on GitHub (do not guess)"
            bio = u.get("bio", "")
            report.append(f"**GitHub:** [{gh_handle}](https://github.com/{gh_handle}) | {name} | {tw_part}\n")
            if bio:
                report.append(f"> {bio[:200]}\n")
    elif maintainers:
        report.append("*GitHub profile not fetched (rate limit or package not enriched).*\n")

    # 5. 아웃리치 메시지
    if product_context:
        growth_msg = f"{item['growth_pct']:+.0f}% growth" if item['growth_pct'] > 0 else "significant adoption"
        base_msg = (
            f"I noticed **{pkg}** is experiencing impressive momentum "
            f"({item['recent_4_avg']:,} weekly downloads, {growth_msg}). Your work on this package "
            f"showcases real expertise in this space. At {product_context}, "
            f"we're building tools that help developers like you save time "
            f"and focus on what matters. I'd love to show you how and get your "
            f"feedback — would you be open to a quick chat?"
        )
        report.append(f"**Suggested Outreach:**")
        report.append(f"> {base_msg}\n")

report_text = "\n".join(report)
print(report_text)

with open("/tmp/npl-report.md", "w") as f:
    f.write(report_text)
print("\n\nReport saved to /tmp/npl-report.md")
PYEOF

아웃리치 섹션이 없는 경우: 사용자에게 제품 컨텍스트를 제공하도록 요청하고 리드 브리프를 다시 생성하십시오.

---

7단계: 요약 제공

리드 브리프 외에도 다음을 포함한 간결한 요약을 사용자에게 제공하십시오:

• 분석된 총 패키지 수
• 'breakout' 패키지 수
• 'watching' 패키지 수
• 생략된 패키지 (too early, steady, established)
• data_quality_flags (발생한 모든 데이터 품질 문제, 예: GitHub 속도 제한 히트 후 불완전한 프로필)

python3 << 'PYEOF'
import json

scored = json.load(open("/tmp/npl-scored.json"))
enriched = json.load(open("/tmp/npl-enriched.json"))

breakout_count = len([p for p in scored if p["tier"] == "breakout"])
watching_count = len([p for p in scored if p["tier"] == "watching"])
too_early_count = len([p for p in scored if p["tier"] == "too_early"])
steady_count = len([p for p in scored if p["tier"] in ("steady", "established")])

flags = []
# GitHub 속도 제한 확인 (pretend check -- actual check was in step 5)
if enriched and len(enriched) < (breakout_count + watching_count):
    flags.append("GitHub rate limit may have limited profile enrichment")

print("## Summary")
print(f"**Total packages analyzed:** {len(scored)}")
print(f"**Breakout packages:** {breakout_count}")
print(f"**Watching packages:** {watching_count}")
print(f"**Skipped packages:** {too_early_count} too early + {steady_count} steady/established")
if flags:
    print(f"\n**Data Quality Flags:** {'; '.join(flags)}")
PYEOF

---

전체 파이프라인 예시

# 분석할 패키지와 컨텍스트 설정
PACKAGES="esbuild, zod, @hono/hono, valibot, vitest"
CONTEXT="We build AI-powered code review tools for JavaScript developers."

# 3단계: 스크립트로 전체 가져오기 및 점수 계산 실행
python3 scripts/fetch.py "$PACKAGES" --context "$CONTEXT" --output /tmp/npl-script-out.json

# 6단계: 리드 브리프 보고서 생성 (스크립트가 이미 profile 필드가 있는 enriched 출력을 생성했다고 가정)
python3 << 'PYEOF'
import json

out = json.load(open("/tmp/npl-script-out.json"))
scored = out["results"]
enriched = [r for r in scored if "profile" in r]

# 각 breakout/watching 패키지에 대한 리드 섹션 출력 (보강됨)
for item in enriched:
    if item.get("tier") not in ("breakout", "watching"):
        continue
    prof = item["profile"]
    print(f"\n--- {item['package']} ({item['tier'].upper()}) ---")
    print(f"Score: {item['velocity_score']} | Growth: {item['growth_pct']:+.0f}% | "
          f"Recent 4-wk: {item['recent_4_avg']:,}")
    for u in prof.get("github_users", []):
        tw = f"@{u['twitter_username']}" if u.get('twitter_username') else "not found on GitHub"
        print(f"  GitHub: {u['github_username']} | {u['name']} | Twitter: {tw}")
    if out.get("product_context"):
        print(f"  Outreach: Hey, I saw {item['package']} growing {item['growth_pct']:+.0f}%...")
PYEOF