scripts/seed_musehub.py · gabriel/musehub

body=f"## v0.1.0 — Early Draft\n\nFirst checkpoint. Basic groove locked in.\n\n### Tracks\n- Main groove\n- Bass foundation\n\n### Technical\nInitial BPM and key established.",

2031

commit_id=commits[min(4, len(commits)-1)]["commit_id"],

2032

download_urls={"midi_bundle": f"/releases/{repo_id}-v0.1.0.zip"},

2033

author=owner,

2034

created_at=_now(days=45)),

2035

dict(release_id=_uid(f"release-{repo_id}-v0.2.0"),

2036

repo_id=repo_id, tag="v0.2.0", title="Arrangement Draft",

2037

body=f"## v0.2.0 — Arrangement Draft\n\nAll major sections sketched.\n\n### What's new\n- Additional instrument layers\n- Section transitions defined\n- Dynamic arc mapped",

2038

commit_id=commits[min(12, len(commits)-1)]["commit_id"],

2039

download_urls={"midi_bundle": f"/releases/{repo_id}-v0.2.0.zip", "mp3": f"/releases/{repo_id}-v0.2.0.mp3"},

2040

author=owner,

2041

created_at=_now(days=25)),

2042

dict(release_id=_uid(f"release-{repo_id}-v1.0.0"),

2043

repo_id=repo_id, tag="v1.0.0", title=f"{repo_name} — Full Release",

2044

body=f"## v1.0.0 — Full Release\n\nProduction-ready state.\n\n### Highlights\n- Complete arrangement with all instruments\n- Mixed and mastered\n- Stems included\n\n### Downloads\nMIDI bundle, MP3 stereo mix, individual stems",

2045

commit_id=commits[-1]["commit_id"],

2046

download_urls={"midi_bundle": f"/releases/{repo_id}-v1.0.0.zip",

2047

"mp3": f"/releases/{repo_id}-v1.0.0.mp3",

2048

"stems": f"/releases/{repo_id}-v1.0.0-stems.zip"},

2049

author=owner,

2050

created_at=_now(days=5)),

]

# ---------------------------------------------------------------------------

2055

# Session templates

2056

# ---------------------------------------------------------------------------

2057

2058

def _make_sessions(repo_id: str, owner: str, commits: list[dict[str, Any]]) -> list[dict[str, Any]]:

2059

"""Generate 6 collaboration sessions per repo; adds a live session for high-traffic repos."""

if len(commits) < 2:

return []

sess = []

collab_map: dict[str, list[tuple[str, ...]]] = {

2064

REPO_NEO_SOUL: [("gabriel", "marcus"), ("gabriel",), ("gabriel", "marcus", "aaliya")],

2065

REPO_MODAL_JAZZ: [("gabriel", "marcus"), ("gabriel",)],

2066

REPO_AMBIENT: [("sofia", "yuki"), ("sofia",), ("sofia", "pierre")],

2067

REPO_AFROBEAT: [("aaliya", "fatou"), ("aaliya",), ("aaliya", "marcus")],

2068

REPO_FUNK_SUITE: [("marcus", "gabriel"), ("marcus",)],

2069

REPO_JAZZ_TRIO: [("marcus",), ("marcus", "gabriel")],

2070

REPO_DRUM_MACHINE: [("fatou",), ("fatou", "aaliya")],

2071

REPO_CHANSON: [("pierre",), ("pierre", "sofia")],

2072

REPO_GRANULAR: [("yuki",), ("yuki", "sofia")],

2073

REPO_MICROTONAL: [("chen",)],

2074

}

2075

collab_groups: list[tuple[str, ...]] = collab_map.get(repo_id) or [(owner,)]

2076

locations = [

2077

"Studio A, São Paulo", "Home studio", "Remote",

2078

"Abbey Road Studio 3", "Electric Lady Studios", "Remote (async)",

2079

"Bedroom studio, Tokyo", "La Fabrique, Marseille",

2080

]

2081

for i, group in enumerate((collab_groups * 3)[:6]):

2082

start_days = 60 - i * 8

2083

dur_hours = [3, 4, 2, 5, 2, 3][i % 6]

2084

commit_slice = commits[i * 4:i * 4 + 3] if len(commits) > i * 4 + 3 else commits[-2:]

2085

sess.append(dict(

2086

session_id=_uid(f"sess-{repo_id}-{i}"),

2087

repo_id=repo_id,

2088

started_at=_now(days=start_days),

2089

ended_at=_now(days=start_days, hours=-dur_hours),

2090

participants=list(group),

2091

location=locations[i % len(locations)],

2092

intent=f"Session {i+1}: extend arrangement and refine mix",

2093

commits=[c["commit_id"] for c in commit_slice],

2094

notes=f"Productive session. Focused on {'groove' if i % 2 == 0 else 'arrangement'}.",

2095

is_active=False,

2096

created_at=_now(days=start_days),

2097

))

2098

# Add one live/active session for the first big repo

2099

if repo_id in (REPO_NEO_SOUL, REPO_AFROBEAT):

2100

sess.append(dict(

2101

session_id=_uid(f"sess-{repo_id}-live"),

2102

repo_id=repo_id,

2103

started_at=_now(hours=1),

2104

ended_at=None,

2105

participants=[owner, "marcus"],

2106

location="Studio A — Live",

2107

intent="Live recording session — tracking final takes",

commits=[],

notes="",

is_active=True,

created_at=_now(hours=1),

))

return sess

# ---------------------------------------------------------------------------

2117

# Webhook + delivery templates

2118

# ---------------------------------------------------------------------------

2119

2120

def _make_webhooks(

2121

repo_id: str, owner: str

2122

) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:

2123

"""Generate 3 webhook subscriptions and 10–15 deliveries per webhook.

2124

2125

Delivery outcomes cycle through 200 (success), 500 (server error), and

2126

0/timeout patterns so every status is represented in the dataset.

2127

Returns (webhooks, deliveries).

2128

"""

2129

webhooks: list[dict[str, Any]] = []

2130

deliveries: list[dict[str, Any]] = []

2131

2132

wh_configs = [

2133

dict(suffix="push", url=f"https://hooks.example.com/{owner}/push",

2134

events=["push"], active=True),

2135

dict(suffix="pr", url=f"https://hooks.example.com/{owner}/pr",

2136

events=["pull_request", "issue"], active=True),

2137

dict(suffix="release", url=f"https://hooks.example.com/{owner}/release",

2138

events=["release"], active=False),

2139

]

2140

2141

for wh_spec in wh_configs:

2142

wh_suffix: str = wh_spec["suffix"] # type: ignore[assignment]

2143

wh_url: str = wh_spec["url"] # type: ignore[assignment]

2144

wh_events: list[str] = wh_spec["events"] # type: ignore[assignment]

2145

wh_active: bool = wh_spec["active"] # type: ignore[assignment]

2146

wh_id = _uid(f"wh-{repo_id}-{wh_suffix}")

2147

webhooks.append(dict(

webhook_id=wh_id,

repo_id=repo_id,

url=wh_url,

events=wh_events,

secret=_sha(f"secret-{repo_id}-{wh_suffix}")[:32],

2153

active=wh_active,

2154

created_at=_now(days=60),

2155

))

2156

2157

# 10–15 deliveries per webhook; cycle through status patterns.

2158

n_deliveries = 10 + (int(_sha(f"nd-{repo_id}-{wh_suffix}")[:2], 16) % 6)

2159

for j in range(n_deliveries):

2160

# Pattern (period 7): 200, 200, 500, 200, 200, timeout, 200

2161

pattern = j % 7

2162

if pattern in (0, 1, 3, 4, 6):

2163

success, status, resp_body = True, 200, '{"ok": true}'

2164

elif pattern == 2:

2165

success, status, resp_body = False, 500, '{"error": "Internal Server Error"}'

2166

else: # pattern == 5 → timeout

2167

success, status, resp_body = False, 0, ""

2168

2169

event_type = wh_events[j % len(wh_events)]

2170

payload_data = (

2171

f'{{"event": "{event_type}", "repo": "{repo_id}", '

2172

f'"attempt": {(j % 3) + 1}, "ts": "{_now(days=j).isoformat()}"}}'

2173

)

2174

deliveries.append(dict(

2175

delivery_id=_uid(f"del-{wh_id}-{j}"),

2176

webhook_id=wh_id,

2177

event_type=event_type,

2178

payload=payload_data,

2179

attempt=(j % 3) + 1,

2180

success=success,

2181

response_status=status,

2182

response_body=resp_body,

2183

delivered_at=_now(days=j),

2184

))

2185

2186

return webhooks, deliveries

2187

2188

2189

# ---------------------------------------------------------------------------

2190

# PR comment templates

2191

# ---------------------------------------------------------------------------

2192

2193

_PR_COMMENT_POOL: list[dict[str, Any]] = [

2194

dict(target_type="general", target_track=None, target_beat_start=None,

2195

target_beat_end=None, target_note_pitch=None,

2196

body="Overall approach looks good. The counter-melody adds the harmonic tension the arrangement was missing. LGTM with minor comments below."),

2197

dict(target_type="track", target_track="bass", target_beat_start=None,

2198

target_beat_end=None, target_note_pitch=None,

2199

body="The bass track humanization is much improved. Ghost notes at beats 2.5 and 3.5 are well-placed.\n\n> Suggest reducing velocity on the ghost at beat 3.5 by 10 units."),

2200

dict(target_type="region", target_track="keys", target_beat_start=9.0,

2201

target_beat_end=17.0, target_note_pitch=None,

2202

body="Bars 9-16: the Rhodes voicing here feels crowded. Try removing the 5th — root + 3rd + 7th is cleaner."),

2203

dict(target_type="note", target_track="trumpet", target_beat_start=24.0,

2204

target_beat_end=None, target_note_pitch=84,

2205

body="This high C (MIDI 84) at beat 24 is above idiomatic range. Transpose down an octave to C5 (MIDI 72)."),

2206

dict(target_type="general", target_track=None, target_beat_start=None,

2207

target_beat_end=None, target_note_pitch=None,

2208

body="The tritone substitution is elegant. I'd approve as-is but @gabriel should confirm alignment with the arrangement plan."),

2209

dict(target_type="track", target_track="drums", target_beat_start=None,

2210

target_beat_end=None, target_note_pitch=None,

2211

body="Drum humanization is a big improvement. Hi-hat timing now feels natural.\n\nOne nit: the ride bell at beat 4 is slightly too loud — try velocity 85 instead of 100."),

2212

dict(target_type="region", target_track="strings", target_beat_start=25.0,

2213

target_beat_end=33.0, target_note_pitch=None,

2214

body="Bars 25-32: pizzicato countermelody is beautifully voiced. Staggered entries work well. No changes needed."),

2215

dict(target_type="note", target_track="bass", target_beat_start=13.0,

2216

target_beat_end=None, target_note_pitch=42,

2217

body="This F# (MIDI 42) at beat 13 creates a very dark sub. If intentional — great. If not, try B1 (MIDI 47)."),

2218

dict(target_type="general", target_track=None, target_beat_start=None,

2219

target_beat_end=None, target_note_pitch=None,

2220

body="Reviewed all four parallel-5th instances. Bars 7-8 and 15-16 are fixed. Bars 23-24 still have a parallel octave between violin and cello — please fix before merging."),

2221

dict(target_type="track", target_track="vocals", target_beat_start=None,

2222

target_beat_end=None, target_note_pitch=None,

2223

body="Vocal sibilance is still present on sustained S sounds. De-esser threshold needs to be 3dB lower. Otherwise the PR is ready."),

]

def _make_pr_comments(

2228

pr_id: str, repo_id: str, pr_n: int, owner: str, days_ago: int

2229

) -> list[dict[str, Any]]:

2230

"""Generate 3–8 inline review comments for a single pull request.

2231

2232

Uses the rotating _PR_COMMENT_POOL with author cycling across the user roster.

2233

Some comments thread as replies via parent_comment_id.

2234

"""

2235

pool_size = len(_PR_COMMENT_POOL)

2236

authors = ["gabriel", "sofia", "marcus", "yuki", "aaliya", "chen", "fatou", "pierre"]

2237

n_comments = 3 + (pr_n % 6) # yields 3–8 per PR

2238

comments: list[dict[str, Any]] = []

2239

first_comment_id: str | None = None

2240

2241

for i in range(n_comments):

2242

pool_entry = _PR_COMMENT_POOL[(pr_n * 5 + i * 3) % pool_size]

2243

author = authors[(pr_n + i + 2) % len(authors)]

2244

if author == owner and i == 0:

2245

author = authors[(pr_n + i + 3) % len(authors)]

2246

2247

comment_id = _uid(f"pr-cmt-{repo_id}-{pr_n}-{i}")

2248

parent_id: str | None = None

2249

# Comments 3+ thread under the first comment to simulate replies.

2250

if i >= 3 and first_comment_id is not None:

2251

parent_id = first_comment_id

2252

2253

comments.append(dict(

2254

comment_id=comment_id,

pr_id=pr_id,

repo_id=repo_id,

author=author,

body=pool_entry["body"],

2259

target_type=pool_entry["target_type"],

2260

target_track=pool_entry["target_track"],

2261

target_beat_start=pool_entry["target_beat_start"],

2262

target_beat_end=pool_entry["target_beat_end"],

2263

target_note_pitch=pool_entry["target_note_pitch"],

2264

parent_comment_id=parent_id,

2265

created_at=_now(days=days_ago - i),

2266

))

2267

if i == 0:

2268

first_comment_id = comment_id

return comments

# ---------------------------------------------------------------------------

2274

# Main seed function

2275

# ---------------------------------------------------------------------------

2276

2277

async def seed(db: AsyncSession, force: bool = False) -> None:

2278

"""Populate all MuseHub tables with a realistic stress-test dataset.

2279

2280

Inserts users, repos, commits, branches, issues, PRs, releases, sessions,

2281

social graph (stars, follows, watches, comments, reactions, notifications,

2282

forks, view/download events), and the full Muse VCS layer (objects,

2283

snapshots, commits, tags). Pass force=True to wipe and re-seed existing data.

2284

"""

2285

print("🌱 Seeding MuseHub stress-test dataset…")

2286

2287

result = await db.execute(text("SELECT COUNT(*) FROM musehub_repos"))

2288

existing = result.scalar() or 0

2289

2290

if existing > 0 and not force:

2291

print(f" ⚠️ {existing} repo(s) already exist — skipping. Pass --force to wipe and reseed.")

_print_urls()

return

if existing > 0 and force:

2296

print(" 🗑 --force: clearing existing seed data…")

2297

for tbl in [

2298

# Conversation children first

2299

"maestro_message_actions", "maestro_conversation_messages",

2300

"maestro_conversations", "maestro_usage_logs", "maestro_access_tokens",

2301

# Muse variation children first (FK order)

2302

"muse_note_changes", "muse_phrases", "muse_variations",

2303

# Muse VCS — innermost first (tags depend on commits, commits depend on snapshots)

2304

"muse_tags", "muse_commits", "muse_snapshots", "muse_objects",

2305

# MuseHub — children before parents (FK order)

2306

"musehub_download_events", "musehub_view_events", "musehub_forks",

2307

"musehub_notifications", "musehub_watches", "musehub_follows",

2308

"musehub_reactions", "musehub_comments",

2309

"musehub_render_jobs",

2310

"musehub_events",

2311

# Stash children before stash (FK to maestro_users + repos)

2312

"musehub_stash_entries", "musehub_stash",

2313

# Collaborators (FK to maestro_users + repos)

2314

"musehub_collaborators",

2315

"musehub_stars", "musehub_sessions",

2316

# Release assets before releases

2317

"musehub_release_assets", "musehub_releases",

2318

"musehub_webhook_deliveries", "musehub_webhooks",

2319

# PR children before pull_requests

2320

"musehub_pr_labels", "musehub_pr_comments", "musehub_pr_reviews",

2321

"musehub_pull_requests",

2322

# Issue children before issues; milestones after (SET NULL FK)

2323

"musehub_issue_labels", "musehub_issue_milestones",

2324

"musehub_issue_comments",

2325

"musehub_issues", "musehub_milestones",

2326

# Labels after issues/PRs

2327

"musehub_labels",

2328

"musehub_branches",

2329

"musehub_objects", "musehub_commits", "musehub_repos",

2330

"musehub_profiles",

2331

# maestro_users last (other tables FK to it)

2332

"maestro_users",

2333

]:

2334

await db.execute(text(f"DELETE FROM {tbl}"))

2335

await db.flush()

2336

2337

# ── 1. maestro_users (required FK for collaborators + stash) ─────────────

2338

# Mirrors the same user IDs used in musehub_profiles so the FK chain is

2339

# consistent across the whole schema.

2340

all_user_ids_and_names = list(USERS) + list(COMPOSER_USERS)

2341

for uid, _uname, _bio in all_user_ids_and_names:

db.add(User(

id=uid,

budget_cents=2500,

budget_limit_cents=5000,

2346

created_at=_now(days=120),

2347

updated_at=_now(days=1),

2348

))

2349

print(f" ✅ maestro_users: {len(all_user_ids_and_names)}")

await db.flush()

# ── 1b. User profiles (musehub_profiles) ──────────────────────

2354

# Pinned repos show the owner's most prominent repos on their profile page.

2355

_PROFILE_PINS: dict[str, list[str]] = {

2356

GABRIEL: [REPO_NEO_SOUL, REPO_MODAL_JAZZ, REPO_NEO_BAROQUE, REPO_COMMUNITY],

2357

SOFIA: [REPO_AMBIENT],

2358

MARCUS: [REPO_FUNK_SUITE, REPO_JAZZ_TRIO, REPO_RAGTIME_EDM],

2359

YUKI: [REPO_GRANULAR],

2360

AALIYA: [REPO_AFROBEAT, REPO_JAZZ_CHOPIN],

2361

CHEN: [REPO_MICROTONAL, REPO_FILM_SCORE],

2362

FATOU: [REPO_DRUM_MACHINE, REPO_POLYRHYTHM],

2363

PIERRE: [REPO_CHANSON],

2364

BACH: [REPO_WTC, REPO_GOLDBERG],

2365

CHOPIN: [REPO_NOCTURNES],

2366

SCOTT_JOPLIN: [REPO_MAPLE_LEAF],

2367

KEVIN_MACLEOD: [REPO_CIN_STRINGS],

2368

KAI_ENGEL: [REPO_KAI_AMBIENT],

2369

}

2370

all_user_profiles = list(USERS) + list(COMPOSER_USERS)

2371

for uid, uname, _bio in all_user_profiles:

2372

p = PROFILE_DATA.get(uid, {})

2373

db.add(MusehubProfile(

2374

user_id=uid,

2375

username=uname,

2376

display_name=str(p["display_name"]) if p.get("display_name") else uname,

2377

bio=str(p["bio"]) if p.get("bio") else _bio,

2378

avatar_url=f"https://api.dicebear.com/7.x/avataaars/svg?seed={uname}",

2379

location=str(p["location"]) if p.get("location") else None,

2380

website_url=str(p["website_url"]) if p.get("website_url") else None,

2381

twitter_handle=str(p["twitter_handle"]) if p.get("twitter_handle") else None,

2382

is_verified=bool(p.get("is_verified", False)),

2383

cc_license=str(p["cc_license"]) if p.get("cc_license") else None,

2384

pinned_repo_ids=_PROFILE_PINS.get(uid, []),

2385

))

2386

verified_count = sum(1 for uid, _, __ in all_user_profiles if PROFILE_DATA.get(uid, {}).get("is_verified"))

2387

print(f" ✅ Profiles: {len(all_user_profiles)} users ({len(USERS)} community + {len(COMPOSER_USERS)} composer/archive, {verified_count} verified CC)")

2388

2389

# ── 2. Repos ──────────────────────────────────────────────────

2390

all_repos = list(REPOS) + list(GENRE_REPOS)

2391

for r in all_repos:

2392

db.add(MusehubRepo(

2393

repo_id=r["repo_id"],

name=r["name"],

owner=r["owner"],

slug=r["slug"],

owner_user_id=r["owner_user_id"],

2398

visibility=r["visibility"],

2399

description=r["description"],

2400

tags=r["tags"],

2401

key_signature=r["key_signature"],

2402

tempo_bpm=r["tempo_bpm"],

2403

created_at=_now(days=r["days_ago"]),

2404

))

2405

print(f" ✅ Repos: {len(all_repos)} ({len(REPOS)} original + {len(GENRE_REPOS)} genre archive)")

await db.flush()

# ── 3. Commits + Branches ─────────────────────────────────────

2410

all_commits: dict[str, list[dict[str, Any]]] = {}

2411

total_commits = 0

2412

for r in all_repos:

2413

repo_id = r["repo_id"]

2414

rkey = REPO_KEY_MAP.get(repo_id, "neo-soul")

2415

n = COMMIT_COUNTS.get(repo_id, 20)

2416

commits = _make_commits(repo_id, rkey, n)

2417

all_commits[repo_id] = commits

2418

total_commits += len(commits)

2419

for c in commits:

2420

db.add(MusehubCommit(**c))

2421

# main branch always points to HEAD

2422

db.add(MusehubBranch(repo_id=repo_id, name="main",

2423

head_commit_id=commits[-1]["commit_id"]))

2424

if repo_id in GENRE_REPO_BRANCHES:

2425

# Genre archive repos: use specific named branches

2426

for branch_name, offset in GENRE_REPO_BRANCHES[repo_id]:

2427

idx = max(0, len(commits) - 1 - offset)

2428

db.add(MusehubBranch(

2429

repo_id=repo_id,

2430

name=branch_name,

2431

head_commit_id=commits[idx]["commit_id"],

2432

))

2433

else:

2434

# Original repos: generic feature branches

2435

if len(commits) > 10:

2436

db.add(MusehubBranch(repo_id=repo_id, name="feat/develop",

2437

head_commit_id=commits[-4]["commit_id"]))

2438

if len(commits) > 20:

2439

db.add(MusehubBranch(repo_id=repo_id, name="experiment/alternate-harmony",

2440

head_commit_id=commits[-8]["commit_id"]))

2441

print(f" ✅ Commits: {total_commits} across {len(all_repos)} repos")

await db.flush()

# ── 4. Objects (track breakdown bar) ──────────────────────────

2446

obj_count = 0

2447

for r in all_repos:

2448

repo_id = r["repo_id"]

2449

rkey = REPO_KEY_MAP.get(repo_id, "neo-soul")

2450

tracks = REPO_TRACKS.get(rkey, REPO_TRACKS["neo-soul"])

2451

commits = all_commits.get(repo_id, [])

2452

if not commits:

2453

continue

2454

# Attach objects to the last 3 commits

2455

for commit in commits[-3:]:

2456

cid = commit["commit_id"]

2457

for role, path in tracks:

2458

obj_id = f"sha256:{_sha(f'{cid}-{path}')}"

2459

db.add(MusehubObject(

object_id=obj_id,

repo_id=repo_id,

path=path,

size_bytes=len(path) * 1024,

2464

disk_path=f"/app/objects/{repo_id}/{obj_id[7:15]}.mid",

2465

created_at=commit["timestamp"],

2466

))

2467

obj_count += 1

2468

print(f" ✅ Objects: {obj_count} track files")

await db.flush()

# ── 4b. Labels (scoped to each repo — seeded before issues/PRs) ───────────

2473

_LABEL_DEFS: list[tuple[str, str, str]] = [

2474

# (name, color, description)

2475

("bug", "#d73a4a", "Something isn't working correctly"),

2476

("enhancement", "#a2eeef", "New feature or improvement request"),

2477

("documentation","#0075ca", "Documentation update or correction"),

2478

("question", "#d876e3", "Further information requested"),

2479

("wontfix", "#ffffff", "This will not be addressed"),

2480

("good first issue", "#7057ff", "Good for newcomers to the project"),

2481

("help wanted", "#008672", "Extra attention needed"),

2482

("in progress", "#e4e669", "Currently being worked on"),

2483

("blocked", "#e11d48", "Blocked by another issue or dependency"),

2484

("harmony", "#fbbf24", "Harmonic or tonal issue"),

2485

("timing", "#6366f1", "Timing, groove or quantization issue"),

2486

("mixing", "#10b981", "Mix balance, levels or EQ"),

2487

("arrangement", "#f97316", "Arrangement or structure feedback"),

2488

]

2489

# Structure: repo_id → {label_name → label_id}

2490

label_id_map: dict[str, dict[str, str]] = {}

2491

label_count = 0

2492

for r in all_repos:

2493

repo_id = r["repo_id"]

2494

label_id_map[repo_id] = {}

2495

for lname, lcolor, ldesc in _LABEL_DEFS:

2496

lid = _uid(f"label-{repo_id}-{lname}")

db.add(MusehubLabel(

id=lid,

repo_id=repo_id,

name=lname,

color=lcolor,

description=ldesc,

created_at=_now(days=r["days_ago"]),

2504

))

2505

label_id_map[repo_id][lname] = lid

2506

label_count += 1

2507

print(f" ✅ Labels: {label_count} ({len(_LABEL_DEFS)} per repo × {len(all_repos)} repos)")

await db.flush()

# ── 5a. Milestones (seed before issues so milestone_id can be referenced) ──

2512

# Structure: repo_id → {milestone_n → milestone_id}

2513

milestone_id_map: dict[str, dict[int, str]] = {}

2514

milestone_count = 0

2515

for r in REPOS:

2516

repo_id = r["repo_id"]

2517

rkey = REPO_KEY_MAP.get(repo_id, "neo-soul")

2518

ms_list = MILESTONE_TEMPLATES.get(rkey, [])

2519

if not ms_list:

2520

continue

2521

milestone_id_map[repo_id] = {}

2522

for ms in ms_list:

2523

mid = _uid(f"milestone-{repo_id}-{ms['n']}")

2524

due = _now(days=-ms["due_days"]) if ms.get("due_days") else None

2525

db.add(MusehubMilestone(

milestone_id=mid,

repo_id=repo_id,

number=ms["n"],

title=ms["title"],

description=ms["description"],

state=ms["state"],

author=r["owner"],

due_on=due,

created_at=_now(days=r["days_ago"]),

2535

))

2536

milestone_id_map[repo_id][ms["n"]] = mid

2537

milestone_count += 1

2538

print(f" ✅ Milestones: {milestone_count}")

await db.flush()

# ── 5b. Issues (track IDs for comment and milestone-link seeding) ──────────

2543

issue_count = 0

2544

# Structure: repo_id → {issue_n → issue_id}

2545

issue_id_map: dict[str, dict[int, str]] = {}

2546

for r in all_repos:

2547

repo_id = r["repo_id"]

2548

rkey = REPO_KEY_MAP.get(repo_id, "neo-soul")

2549

issue_list = ISSUE_TEMPLATES.get(rkey, GENERIC_ISSUES)

2550

days_base = r["days_ago"]

2551

# Determine milestone assignment map for this repo: issue_n → milestone_n

2552

ms_assignments = MILESTONE_ISSUE_ASSIGNMENTS.get(rkey, {})

2553

issue_to_ms: dict[int, int] = {}

2554

for ms_number, issue_ns in ms_assignments.items():

2555

for iss_n in issue_ns:

2556

issue_to_ms[iss_n] = ms_number

2557

2558

issue_id_map[repo_id] = {}

2559

for iss in issue_list:

2560

iid = _uid(f"issue-{repo_id}-{iss['n']}")

2561

assigned_ms_n: int | None = issue_to_ms.get(iss["n"])

2562

ms_id: str | None = milestone_id_map.get(repo_id, {}).get(assigned_ms_n) if assigned_ms_n else None

db.add(MusehubIssue(

issue_id=iid,

repo_id=repo_id,

number=iss["n"],

state=iss["state"],

title=iss["title"],

body=iss["body"],

labels=iss["labels"],

2571

author=r["owner"],

2572

milestone_id=ms_id,

2573

created_at=_now(days=days_base - iss["n"] * 2),

2574

))

2575

issue_id_map[repo_id][iss["n"]] = iid

2576

# Also populate MusehubIssueMilestone join table for repos with milestones

2577

if ms_id:

2578

db.add(MusehubIssueMilestone(issue_id=iid, milestone_id=ms_id))

2579

issue_count += 1

2580

print(f" ✅ Issues: {issue_count}")

await db.flush()

# ── 5b-ii. Issue labels (many-to-many join) ────────────────────────────────

2585

_ISSUE_LABEL_PICKS: list[list[str]] = [

2586

# Cycling pattern of label combos assigned to issues by index

2587

["bug"],

2588

["enhancement"],

2589

["bug", "in progress"],

["question"],

["harmony"],

["timing"],

["mixing"],

["arrangement"],

["enhancement", "help wanted"],

2596

["bug", "blocked"],

2597

["documentation"],

2598

["good first issue"],

2599

["wontfix"],

2600

["enhancement", "in progress"],

2601

["harmony", "help wanted"],

2602

]

2603

issue_label_count = 0

2604

for r in all_repos:

2605

repo_id = r["repo_id"]

2606

rkey = REPO_KEY_MAP.get(repo_id, "neo-soul")

2607

issue_list = ISSUE_TEMPLATES.get(rkey, GENERIC_ISSUES)

2608

repo_labels = label_id_map.get(repo_id, {})

2609

for iss in issue_list:

2610

il_iid: str | None = issue_id_map.get(repo_id, {}).get(iss["n"])

2611

if not il_iid:

2612

continue

2613

picks = _ISSUE_LABEL_PICKS[iss["n"] % len(_ISSUE_LABEL_PICKS)]

2614

for lname in picks:

2615

il_lid: str | None = repo_labels.get(lname)

2616

if il_lid:

2617

db.add(MusehubIssueLabel(issue_id=il_iid, label_id=il_lid))

2618

issue_label_count += 1

2619

print(f" ✅ Issue labels: {issue_label_count}")

await db.flush()

# ── 5c. Issue comments (5-10 per issue, with @mentions and code blocks) ────

2624

issue_comment_count = 0

2625

users_list = [u[1] for u in USERS]

2626

for r in REPOS[:10]: # Comments on all non-fork repos

2627

repo_id = r["repo_id"]

2628

rkey = REPO_KEY_MAP.get(repo_id, "neo-soul")

2629

issue_list = ISSUE_TEMPLATES.get(rkey, GENERIC_ISSUES)

2630

for iss in issue_list:

2631

iss_iid = issue_id_map.get(repo_id, {}).get(iss["n"])

2632

if not iss_iid:

2633

continue

2634

# 5-10 comments per issue (varies by issue number parity)

2635

n_comments = 5 + (iss["n"] % 6)

2636

iss_cmt_parent: str | None = None

2637

for j in range(n_comments):

2638

cmt_seed = hash(repo_id + str(iss["n"]) + str(j)) % 1000

2639

body = _make_issue_comment_body(cmt_seed)

2640

musical_refs = _make_issue_musical_refs(body)

2641

author_idx = (abs(hash(repo_id)) + iss["n"] + j) % len(users_list)

2642

author = users_list[author_idx]

2643

cid = _uid(f"iss-comment-{repo_id}-{iss['n']}-{j}")

2644

db.add(MusehubIssueComment(

comment_id=cid,

issue_id=iss_iid,

repo_id=repo_id,

author=author,

body=body,

parent_id=iss_cmt_parent if j > 0 and j % 3 == 0 else None,

2651

musical_refs=musical_refs,

2652

created_at=_now(days=r["days_ago"] - iss["n"] * 2, hours=j * 2),

2653

))

2654

issue_comment_count += 1

2655

# First comment becomes parent for threaded replies

2656

if j == 0:

2657

iss_cmt_parent = cid

2658

print(f" ✅ Issue comments: {issue_comment_count}")

await db.flush()

# ── 6. Pull Requests ──────────────────────────────────────────

2663

pr_count = 0

2664

pr_ids: dict[str, list[str]] = {}

2665

for r in all_repos:

2666

repo_id = r["repo_id"]

2667

commits = all_commits.get(repo_id, [])

2668

prs = _make_prs(repo_id, commits, r["owner"])

2669

pr_ids[repo_id] = [p["pr_id"] for p in prs]

2670

for pr in prs:

2671

db.add(MusehubPullRequest(**pr))

2672

pr_count += 1

2673

print(f" ✅ Pull Requests: {pr_count}")

await db.flush()

# ── 6b. PR comments (3-8 per PR with target_type variety) ─────────────────

2678

PR_COMMENT_BODIES: list[tuple[str, str, str | None, float | None, float | None, int | None]] = [

2679

# (body, target_type, target_track, beat_start, beat_end, note_pitch)

2680

("General: this PR looks good overall. The groove change is an improvement.",

2681

"general", None, None, None, None),

2682

("The `bass` track changes in this PR need review — the wah envelope is still too slow.",

2683

"track", "bass", None, None, None),

2684

("This region (beats 16-24) sounds much better with the humanized timing.",

2685

"region", "keys", 16.0, 24.0, None),

2686

("The C#4 (MIDI 61) note in the Rhodes feels misplaced — should be D4 for the chord.",

2687

"note", "keys", None, None, 61),

2688

("Great improvement in the horns section. The harmony is now correct.",

2689

"track", "horns", None, None, None),

2690

("The beat 1-8 region on the bass now locks properly with the kick.",

2691

"region", "bass", 1.0, 8.0, None),

2692

("The G3 (MIDI 55) in bar 7 creates an unwanted clash. Remove or lower octave.",

2693

"note", "strings", None, None, 55),

2694

("Overall this PR solves the main issue. LGTM with minor nits.",

2695

"general", None, None, None, None),

2696

("The `drums` ghost notes are much improved — much more human now.",

2697

"track", "drums", None, None, None),

2698

("Beats 32-40 on the guitar feel slightly rushed. Did you check the quantize grid?",

2699

"region", "guitar", 32.0, 40.0, None),

]

pr_comment_count = 0

for r in REPOS[:10]:

repo_id = r["repo_id"]

2705

for pr_id_str in pr_ids.get(repo_id, []):

2706

# 3-8 comments per PR

2707

n_pr_comments = 3 + (abs(hash(pr_id_str)) % 6)

2708

parent_pr_cid: str | None = None

2709

for k in range(n_pr_comments):

2710

tmpl_idx = (abs(hash(pr_id_str)) + k) % len(PR_COMMENT_BODIES)

2711

body, ttype, ttrack, tbs, tbe, tnp = PR_COMMENT_BODIES[tmpl_idx]

2712

author_idx = (abs(hash(repo_id)) + k + 1) % len(users_list)

2713

pr_cid = _uid(f"pr-comment-{pr_id_str}-{k}")

2714

db.add(MusehubPRComment(

comment_id=pr_cid,

pr_id=pr_id_str,

repo_id=repo_id,

author=users_list[author_idx],

body=body,

target_type=ttype,

target_track=ttrack,

target_beat_start=tbs,

2723

target_beat_end=tbe,

2724

target_note_pitch=tnp,

2725

parent_comment_id=parent_pr_cid if k > 0 and k % 4 == 0 else None,

2726

created_at=_now(days=7 - k),

2727

))

2728

pr_comment_count += 1

2729

if k == 0:

2730

parent_pr_cid = pr_cid

2731

print(f" ✅ PR comments: {pr_comment_count}")

await db.flush()

# ── 6c. PR Reviews (reviewer assignment + approved/changes_requested) ──────

2736

_PR_REVIEW_STATES = ["approved", "approved", "changes_requested", "pending", "dismissed"]

2737

_PR_REVIEW_BODIES = [

2738

"LGTM — the harmonic changes are solid and the voice-leading is now clean.",

2739

"Approved. The groove is much tighter after the timing adjustments.",

2740

"Changes requested: the bass still feels muddy in bars 9-16. Please reduce low-mids.",

2741

"Pending review — I'll listen through the changes this weekend.",

2742

"Approved with nits: the coda could be shorter, but the core change is correct.",

2743

"Changes requested: parallel fifths still present in bar 7 on the strings voice.",

2744

"LGTM — the new arrangement section is exactly what the composition needed.",

]

pr_review_count = 0

for r in REPOS[:10]:

repo_id = r["repo_id"]

2749

owner = r["owner"]

2750

for pr_id_str in pr_ids.get(repo_id, []):

2751

# 1-2 reviewers per PR, drawn from the community pool (not the PR author)

2752

n_reviewers = 1 + (abs(hash(pr_id_str)) % 2)

2753

reviewers_pool = [u for u in users_list if u != owner]

2754

for ri in range(n_reviewers):

2755

reviewer = reviewers_pool[(abs(hash(pr_id_str)) + ri) % len(reviewers_pool)]

2756

state = _PR_REVIEW_STATES[(abs(hash(pr_id_str)) + ri) % len(_PR_REVIEW_STATES)]

2757

body = _PR_REVIEW_BODIES[(abs(hash(pr_id_str)) + ri) % len(_PR_REVIEW_BODIES)]

2758

submitted = _now(days=5 - ri) if state != "pending" else None

2759

db.add(MusehubPRReview(

2760

id=_uid(f"pr-review-{pr_id_str}-{ri}"),

2761

pr_id=pr_id_str,

2762

reviewer_username=reviewer,

2763

state=state,

2764

body=body if state != "pending" else None,

2765

submitted_at=submitted,

2766

created_at=_now(days=7 - ri),

2767

))

2768

pr_review_count += 1

2769

print(f" ✅ PR reviews: {pr_review_count}")

await db.flush()

# ── 6d. PR Labels (label tags on pull requests) ────────────────────────────

2774

_PR_LABEL_PICKS: list[list[str]] = [

2775

["enhancement"],

2776

["bug"],

2777

["enhancement", "in progress"],

["wontfix"],

]

pr_label_count = 0

for r in all_repos:

repo_id = r["repo_id"]

2783

repo_labels = label_id_map.get(repo_id, {})

2784

for pi, pr_id_str in enumerate(pr_ids.get(repo_id, [])):

2785

picks = _PR_LABEL_PICKS[pi % len(_PR_LABEL_PICKS)]

2786

for lname in picks:

2787

prl_lid: str | None = repo_labels.get(lname)

2788

if prl_lid:

2789

db.add(MusehubPRLabel(pr_id=pr_id_str, label_id=prl_lid))

2790

pr_label_count += 1

2791

print(f" ✅ PR labels: {pr_label_count}")

await db.flush()

# ── 7. Releases ───────────────────────────────────────────────

2796

release_count = 0

2797

release_tags: dict[str, list[str]] = {}

2798

for r in all_repos:

2799

repo_id = r["repo_id"]

2800

commits = all_commits.get(repo_id, [])

2801

releases = _make_releases(repo_id, commits, r["name"], r["owner"])

2802

release_tags[repo_id] = [rel["tag"] for rel in releases]

2803

for rel in releases:

2804

db.add(MusehubRelease(**rel))

2805

release_count += 1

2806

print(f" ✅ Releases: {release_count}")

await db.flush()

# ── 7b. Release Assets (downloadable file attachments per release) ─────────

2811

_ASSET_TYPES: list[tuple[str, str, str, int]] = [

2812

# (name_suffix, label, content_type, approx_size_bytes)

2813

("-midi-bundle.zip", "MIDI Bundle", "application/zip", 2_400_000),

2814

("-stereo-mix.mp3", "Stereo Mix", "audio/mpeg", 8_200_000),

2815

("-stems.zip", "Stems Archive", "application/zip", 42_000_000),

2816

("-score.pdf", "Score PDF", "application/pdf", 1_100_000),

2817

("-metadata.json", "Metadata", "application/json", 18_000),

2818

]

2819

# Only full releases (v1.0.0) get all 5 assets; earlier releases get 2.

2820

release_asset_count = 0

2821

for r in all_repos:

2822

repo_id = r["repo_id"]

2823

tags = release_tags.get(repo_id, [])

2824

for ti, tag in enumerate(tags):

2825

# release_id is deterministic — matches what _make_releases sets

2826

rel_id = _uid(f"release-{repo_id}-{tag}")

2827

# Full release gets all asset types; earlier releases get 2

2828

n_assets = len(_ASSET_TYPES) if ti == len(tags) - 1 else 2

2829

base_slug = r["slug"]

2830

for ai, (sfx, label, ctype, base_size) in enumerate(_ASSET_TYPES[:n_assets]):

2831

dl_count = max(0, (50 - ti * 15) - ai * 5 + abs(hash(repo_id + tag)) % 20)

2832

db.add(MusehubReleaseAsset(

2833

asset_id=_uid(f"asset-{rel_id}-{ai}"),

2834

release_id=rel_id,

2835

repo_id=repo_id,

2836

name=f"{base_slug}-{tag}{sfx}",

2837

label=label,

2838

content_type=ctype,

2839

size=base_size + abs(hash(repo_id)) % 500_000,

2840

download_url=f"/releases/{repo_id}/{tag}{sfx}",

2841

download_count=dl_count,

2842

created_at=_now(days=max(1, 45 - ti * 20)),

2843

))

2844

release_asset_count += 1

2845

print(f" ✅ Release assets: {release_asset_count}")

await db.flush()

# ── 8. Sessions ───────────────────────────────────────────────

2850

session_count = 0

2851

session_ids: dict[str, list[str]] = {}

2852

for r in all_repos:

2853

repo_id = r["repo_id"]

2854

commits = all_commits.get(repo_id, [])

2855

sessions = _make_sessions(repo_id, r["owner"], commits)

2856

session_ids[repo_id] = [s["session_id"] for s in sessions]

2857

for sess in sessions:

2858

db.add(MusehubSession(**sess))

2859

session_count += 1

2860

print(f" ✅ Sessions: {session_count}")

await db.flush()

# ── 8b. Collaborators (repo access beyond owner) ───────────────────────────

2865

# Each active repo gets 1-3 collaborators from the community pool.

2866

# Collaborators have write permission; the most active repos get an admin.

2867

_COLLAB_CONFIGS: list[tuple[str, str, list[tuple[str, str]]]] = [

2868

# (repo_id, owner_user_id, [(collab_user_id, permission)])

2869

(REPO_NEO_SOUL, GABRIEL, [(MARCUS, "write"), (SOFIA, "write"), (AALIYA, "admin")]),

2870

(REPO_MODAL_JAZZ, GABRIEL, [(MARCUS, "write"), (CHEN, "write")]),

2871

(REPO_AMBIENT, SOFIA, [(YUKI, "write"), (PIERRE, "write"), (GABRIEL, "admin")]),

2872

(REPO_AFROBEAT, AALIYA, [(FATOU, "write"), (GABRIEL, "write")]),

2873

(REPO_MICROTONAL, CHEN, [(PIERRE, "write")]),

2874

(REPO_DRUM_MACHINE, FATOU, [(AALIYA, "write"), (MARCUS, "write")]),

2875

(REPO_CHANSON, PIERRE, [(SOFIA, "write")]),

2876

(REPO_GRANULAR, YUKI, [(SOFIA, "write"), (CHEN, "write")]),

2877

(REPO_FUNK_SUITE, MARCUS, [(GABRIEL, "write"), (AALIYA, "admin")]),

2878

(REPO_JAZZ_TRIO, MARCUS, [(GABRIEL, "write")]),

2879

(REPO_NEO_BAROQUE, GABRIEL, [(PIERRE, "write"), (CHEN, "write")]),

2880

(REPO_JAZZ_CHOPIN, AALIYA, [(GABRIEL, "write"), (MARCUS, "write")]),

2881

(REPO_COMMUNITY, GABRIEL, [(SOFIA, "admin"), (MARCUS, "write"), (YUKI, "write"),

2882

(AALIYA, "write"), (CHEN, "write"), (FATOU, "write"), (PIERRE, "write")]),

2883

]

2884

collab_count = 0

2885

for repo_id, owner_uid, collab_list in _COLLAB_CONFIGS:

2886

for collab_uid, perm in collab_list:

2887

accepted = _now(days=abs(hash(collab_uid + repo_id)) % 20 + 1)

2888

db.add(MusehubCollaborator(

2889

id=_uid(f"collab-{repo_id}-{collab_uid}"),

repo_id=repo_id,

user_id=collab_uid,

permission=perm,

invited_by=owner_uid,

2894

invited_at=_now(days=abs(hash(collab_uid + repo_id)) % 20 + 3),

2895

accepted_at=accepted,

2896

))

2897

collab_count += 1

2898

print(f" ✅ Collaborators: {collab_count}")

await db.flush()

# ── 8c. Stash (shelved in-progress work per user/repo) ────────────────────

2903

_STASH_MESSAGES: list[str] = [

2904

"WIP: Rhodes chord voicings — not ready to commit",

2905

"Experiment: tritone sub on IV chord — might revert",

2906

"Sketching counter-melody — needs more work",

2907

"Bass line draft — 3-against-4 groove not locked yet",

2908

"Drum fills experiment — comparing two approaches",

2909

"Harmony sketch: parallel 10ths — maybe too classical?",

2910

"Tempo map idea: ritardando at bar 36 — not sure yet",

2911

]

2912

_STASH_CONFIGS: list[tuple[str, str, str]] = [

2913

# (repo_id, user_id, branch)

2914

(REPO_NEO_SOUL, GABRIEL, "feat/counter-melody"),

2915

(REPO_AMBIENT, SOFIA, "experiment/drone-layer"),

2916

(REPO_AFROBEAT, AALIYA, "feat/brass-section"),

2917

(REPO_FUNK_SUITE, MARCUS, "experiment/fretless-bass"),

2918

(REPO_MICROTONAL, CHEN, "feat/spectral-harmony"),

2919

(REPO_GRANULAR, YUKI, "experiment/formant-filter"),

2920

(REPO_CHANSON, PIERRE, "feat/coda-extension"),

2921

(REPO_COMMUNITY, GABRIEL, "collab/all-genre-finale"),

2922

(REPO_MODAL_JAZZ, GABRIEL, "feat/mcoy-voicings"),

2923

(REPO_NEO_BAROQUE, GABRIEL, "experiment/fugue-development"),

2924

]

2925

stash_count = 0

2926

stash_entry_count = 0

2927

for si, (repo_id, user_id, branch) in enumerate(_STASH_CONFIGS):

2928

stash_id = _uid(f"stash-{repo_id}-{user_id}-{si}")

2929

msg = _STASH_MESSAGES[si % len(_STASH_MESSAGES)]

2930

is_applied = si % 5 == 0 # Every 5th stash has been popped

2931

applied_at = _now(days=1) if is_applied else None

db.add(MusehubStash(

id=stash_id,

repo_id=repo_id,

user_id=user_id,

branch=branch,

message=msg,

is_applied=is_applied,

2939

created_at=_now(days=si + 2),

2940

applied_at=applied_at,

2941

))

2942

stash_count += 1

2943

# 2-4 MIDI file entries per stash

2944

rkey = REPO_KEY_MAP.get(repo_id, "neo-soul")

2945

stash_tracks = REPO_TRACKS.get(rkey, REPO_TRACKS["neo-soul"])

2946

n_entries = 2 + (si % 3)

2947

for ei, (role, fpath) in enumerate(stash_tracks[:n_entries]):

2948

obj_id = f"sha256:{_sha(f'stash-obj-{stash_id}-{role}')}"

2949

db.add(MusehubStashEntry(

2950

id=_uid(f"stash-entry-{stash_id}-{ei}"),

2951

stash_id=stash_id,

2952

path=f"tracks/{fpath}",

object_id=obj_id,

position=ei,

))

stash_entry_count += 1

2957

print(f" ✅ Stash: {stash_count} stashes, {stash_entry_count} entries")

await db.flush()

# ── 9. Stars (cross-repo) ─────────────────────────────────────

2962

# Every community user stars 5-10 repos; genre/composer archives also get

2963

# starred by community users who inspired or forked from them. 50+ total.

2964

star_pairs = [

2965

# Community repos — broad community engagement

2966

(SOFIA, REPO_NEO_SOUL, 20), (MARCUS, REPO_NEO_SOUL, 18),

2967

(YUKI, REPO_NEO_SOUL, 15), (AALIYA, REPO_NEO_SOUL, 12),

2968

(CHEN, REPO_NEO_SOUL, 10), (FATOU, REPO_NEO_SOUL, 8),

2969

(PIERRE, REPO_NEO_SOUL, 6),

2970

2971

(GABRIEL, REPO_AMBIENT, 14), (MARCUS, REPO_AMBIENT, 12),

2972

(YUKI, REPO_AMBIENT, 10), (AALIYA, REPO_AMBIENT, 9),

2973

(CHEN, REPO_AMBIENT, 7), (FATOU, REPO_AMBIENT, 5),

2974

(PIERRE, REPO_AMBIENT, 3),

2975

2976

(GABRIEL, REPO_AFROBEAT, 8), (SOFIA, REPO_AFROBEAT, 7),

2977

(MARCUS, REPO_AFROBEAT, 6), (YUKI, REPO_AFROBEAT, 5),

2978

(CHEN, REPO_AFROBEAT, 4), (PIERRE, REPO_AFROBEAT, 3),

2979

2980

(GABRIEL, REPO_FUNK_SUITE, 12), (SOFIA, REPO_FUNK_SUITE, 10),

2981

(AALIYA, REPO_FUNK_SUITE, 9), (CHEN, REPO_FUNK_SUITE, 7),

2982

(FATOU, REPO_FUNK_SUITE, 5),

2983

2984

(GABRIEL, REPO_MODAL_JAZZ, 11), (SOFIA, REPO_MODAL_JAZZ, 8),

2985

(MARCUS, REPO_MODAL_JAZZ, 6), (AALIYA, REPO_MODAL_JAZZ, 4),

2986

2987

(GABRIEL, REPO_JAZZ_TRIO, 9), (SOFIA, REPO_JAZZ_TRIO, 7),

2988

(AALIYA, REPO_JAZZ_TRIO, 5), (CHEN, REPO_JAZZ_TRIO, 3),

2989

2990

(GABRIEL, REPO_DRUM_MACHINE, 6), (MARCUS, REPO_DRUM_MACHINE, 4),

2991

(GABRIEL, REPO_GRANULAR, 5), (MARCUS, REPO_GRANULAR, 3),

2992

(GABRIEL, REPO_CHANSON, 4), (SOFIA, REPO_CHANSON, 3),

2993

(GABRIEL, REPO_MICROTONAL, 3), (SOFIA, REPO_MICROTONAL, 2),

2994

2995

# Genre/composer archive repos starred by community users who draw

2996

# inspiration from or fork into them

2997

(GABRIEL, REPO_GOLDBERG, 25), (SOFIA, REPO_GOLDBERG, 22),

2998

(MARCUS, REPO_GOLDBERG, 18), (AALIYA, REPO_GOLDBERG, 15),

2999

(CHEN, REPO_GOLDBERG, 12), (FATOU, REPO_GOLDBERG, 9),

3000

(PIERRE, REPO_GOLDBERG, 7), (YUKI, REPO_GOLDBERG, 5),

3001

3002

(GABRIEL, REPO_WTC, 24), (SOFIA, REPO_WTC, 20),

3003

(CHEN, REPO_WTC, 16), (MARCUS, REPO_WTC, 13),

3004

(YUKI, REPO_WTC, 10), (PIERRE, REPO_WTC, 6),

3005

3006

(GABRIEL, REPO_NOCTURNES, 22), (AALIYA, REPO_NOCTURNES, 18),

3007

(SOFIA, REPO_NOCTURNES, 15), (CHEN, REPO_NOCTURNES, 11),

3008

(MARCUS, REPO_NOCTURNES, 8), (YUKI, REPO_NOCTURNES, 5),

3009

3010

(MARCUS, REPO_MAPLE_LEAF, 20), (GABRIEL, REPO_MAPLE_LEAF, 17),

3011

(AALIYA, REPO_MAPLE_LEAF, 13), (FATOU, REPO_MAPLE_LEAF, 9),

3012

(PIERRE, REPO_MAPLE_LEAF, 6),

3013

3014

(CHEN, REPO_CIN_STRINGS, 19), (GABRIEL, REPO_CIN_STRINGS, 15),

3015

(SOFIA, REPO_CIN_STRINGS, 12), (YUKI, REPO_CIN_STRINGS, 8),

3016

(MARCUS, REPO_CIN_STRINGS, 5),

3017

3018

# Community genre-fusion repos (created as forks of composer archives)

3019

(SOFIA, REPO_NEO_BAROQUE, 14), (MARCUS, REPO_NEO_BAROQUE, 11),

3020

(CHEN, REPO_NEO_BAROQUE, 8), (YUKI, REPO_NEO_BAROQUE, 5),

3021

(PIERRE, REPO_NEO_BAROQUE, 3),

3022

3023

(GABRIEL, REPO_JAZZ_CHOPIN, 12), (MARCUS, REPO_JAZZ_CHOPIN, 9),

3024

(SOFIA, REPO_JAZZ_CHOPIN, 7), (CHEN, REPO_JAZZ_CHOPIN, 4),

3025

3026

(GABRIEL, REPO_RAGTIME_EDM, 10), (AALIYA, REPO_RAGTIME_EDM, 8),

3027

(FATOU, REPO_RAGTIME_EDM, 6), (YUKI, REPO_RAGTIME_EDM, 4),

3028

3029

(GABRIEL, REPO_FILM_SCORE, 9), (SOFIA, REPO_FILM_SCORE, 7),

3030

(MARCUS, REPO_FILM_SCORE, 5), (AALIYA, REPO_FILM_SCORE, 3),

3031

3032

(GABRIEL, REPO_COMMUNITY, 8), (SOFIA, REPO_COMMUNITY, 6),

3033

(MARCUS, REPO_COMMUNITY, 5), (AALIYA, REPO_COMMUNITY, 4),

3034

(CHEN, REPO_COMMUNITY, 3), (FATOU, REPO_COMMUNITY, 2),

3035

(PIERRE, REPO_COMMUNITY, 1),

3036

]

3037

for user_id, repo_id, days in star_pairs:

3038

db.add(MusehubStar(repo_id=repo_id, user_id=user_id,

3039

created_at=_now(days=days)))

3040

print(f" ✅ Stars: {len(star_pairs)}")

await db.flush()

# ── 10. Comments ─────────────────────────────────────────────

3045

COMMENT_BODIES = [

3046

"This groove is incredible — the 3-against-4 polyrhythm is exactly what this track needed.",

3047

"Love the Rhodes voicings here. Upper-structure triads give it that sophisticated neo-soul feel.",

3048

"The humanization really helped. Feels much more like a live performance now.",

3049

"I think the bridge needs more harmonic tension. The IV-I resolution is too settled.",

3050

"That trumpet counter-melody is stunning. It perfectly answers the Rhodes line.",

3051

"Could we push the bass a bit more? It's sitting a little behind the kick drum.",

3052

"The string pizzicato in the verse is a beautiful subtle touch.",

3053

"I'm not sure about the guitar scratch — feels a bit busy with the Rhodes.",

3054

"This is really coming together. The dynamic arc from intro to chorus is perfect.",

3055

"The call-and-response between horns and strings is very Quincy Jones.",

]

comment_count = 0

for r in REPOS[:6]: # Comments on first 6 repos

3060

repo_id = r["repo_id"]

3061

commits = all_commits.get(repo_id, [])

3062

if not commits:

3063

continue

3064

# Comments on latest 3 commits

3065

for i, commit in enumerate(commits[-3:]):

3066

for j in range(3):

3067

body = COMMENT_BODIES[(i * 3 + j) % len(COMMENT_BODIES)]

3068

author_ids = [GABRIEL, SOFIA, MARCUS, YUKI, AALIYA, CHEN, FATOU, PIERRE]

3069

author = [u[1] for u in USERS if u[0] == author_ids[(i + j + hash(repo_id)) % len(author_ids)]][0]

3070

comment_id = _uid(f"comment-{repo_id}-{i}-{j}")

3071

db.add(MusehubComment(

3072

comment_id=comment_id,

3073

repo_id=repo_id,

3074

target_type="commit",

3075

target_id=commit["commit_id"],

author=author,

body=body,

parent_id=None,

created_at=_now(days=2, hours=i * 3 + j),

3080

))

3081

comment_count += 1

3082

# Add a reply to first comment on each commit

3083

if j == 0:

3084

reply_author = [u[1] for u in USERS if u[1] != author][0]

3085

db.add(MusehubComment(

3086

comment_id=_uid(f"reply-{repo_id}-{i}-{j}"),

3087

repo_id=repo_id,

3088

target_type="commit",

3089

target_id=commit["commit_id"],

3090

author=reply_author,

3091

body="Totally agree — this part really elevates the whole track.",

3092

parent_id=comment_id,

3093

created_at=_now(days=1, hours=i * 2),

3094

))

3095

comment_count += 1

3096

print(f" ✅ Comments: {comment_count}")

await db.flush()

# ── 11. Reactions ─────────────────────────────────────────────

3101

# All 8 emoji types from the spec: 👍❤️🎵🔥🎹👏🤔😢. 200+ total across

3102

# both community and genre-archive repos.

3103

EMOJIS = ["👍", "❤️", "🎵", "🔥", "🎹", "👏", "🤔", "😢"]

3104

reaction_count = 0

3105

all_community_users = [GABRIEL, SOFIA, MARCUS, YUKI, AALIYA, CHEN, FATOU, PIERRE]

3106

# Community repos — all 8 users react to last 5 commits on first 6 repos

3107

for r in REPOS[:6]:

3108

repo_id = r["repo_id"]

3109

commits = all_commits.get(repo_id, [])

3110

if not commits:

3111

continue

3112

for commit in commits[-5:]:

3113

for i, uid in enumerate(all_community_users):

3114

emoji = EMOJIS[i % len(EMOJIS)]

3115

try:

3116

db.add(MusehubReaction(

3117

reaction_id=_uid(f"reaction-{repo_id}-{commit['commit_id'][:8]}-{uid}"),

3118

repo_id=repo_id,

3119

target_type="commit",

3120

target_id=commit["commit_id"],

3121

user_id=uid,

3122

emoji=emoji,

3123

created_at=_now(days=1),

))

reaction_count += 1

except Exception:

pass

# Genre-archive repos — community users react to last 3 commits, rotating

3129

# through all emoji types to ensure full coverage

3130

genre_reaction_repos = [

3131

REPO_GOLDBERG, REPO_WTC, REPO_NOCTURNES, REPO_MAPLE_LEAF, REPO_CIN_STRINGS,

3132

]

3133

for repo_id in genre_reaction_repos:

3134

commits = all_commits.get(repo_id, [])

3135

if not commits:

3136

continue

3137

for ci, commit in enumerate(commits[-3:]):

3138

for ui, uid in enumerate(all_community_users):

3139

emoji = EMOJIS[(ci * len(all_community_users) + ui) % len(EMOJIS)]

3140

try:

3141

db.add(MusehubReaction(

3142

reaction_id=_uid(f"reaction-g-{repo_id[:12]}-{commit['commit_id'][:8]}-{uid}"),

3143

repo_id=repo_id,

3144

target_type="commit",

3145

target_id=commit["commit_id"],

3146

user_id=uid,

3147

emoji=emoji,

3148

created_at=_now(days=2),

))

reaction_count += 1

except Exception:

pass

print(f" ✅ Reactions: {reaction_count}")

await db.flush()

# ── 12. Follows (social graph) ────────────────────────────────

3158

# Rich bidirectional follow graph: gabriel↔sofia, marcus↔fatou,

3159

# yuki↔chen, aaliya↔pierre, plus composer-to-community asymmetric follows.

3160

# 60+ total, preserving all prior pairs.

3161

follow_pairs = [

3162

# Original follows — gabriel is the hub (everyone follows him)

3163

(SOFIA, GABRIEL), (MARCUS, GABRIEL), (YUKI, GABRIEL),

3164

(AALIYA, GABRIEL), (CHEN, GABRIEL), (FATOU, GABRIEL),

3165

(PIERRE, GABRIEL),

3166

3167

# Bidirectional close collaborator pairs (symmetric)

3168

(GABRIEL, SOFIA), (SOFIA, GABRIEL), # already added above, deduped by _uid

3169

(MARCUS, FATOU), (FATOU, MARCUS),

3170

(YUKI, CHEN), (CHEN, YUKI),

3171

(AALIYA, PIERRE), (PIERRE, AALIYA),

3172

3173

# Cross-community follows

3174

(GABRIEL, MARCUS), (SOFIA, MARCUS), (AALIYA, MARCUS),

3175

(GABRIEL, YUKI), (SOFIA, YUKI),

3176

(GABRIEL, AALIYA), (MARCUS, AALIYA),

3177

(GABRIEL, CHEN),

3178

(GABRIEL, FATOU), (AALIYA, FATOU),

3179

(GABRIEL, PIERRE), (SOFIA, PIERRE),

3180

(MARCUS, SOFIA), (PIERRE, SOFIA),

3181

(MARCUS, YUKI), (FATOU, YUKI),

3182

(PIERRE, MARCUS), (YUKI, MARCUS),

3183

(CHEN, MARCUS), (FATOU, SOFIA),

3184

(YUKI, AALIYA), (CHEN, AALIYA), (FATOU, AALIYA),

3185

(MARCUS, CHEN), (AALIYA, CHEN), (PIERRE, CHEN),

3186

(SOFIA, FATOU), (CHEN, FATOU), (PIERRE, FATOU),

3187

(YUKI, PIERRE), (MARCUS, PIERRE), (CHEN, PIERRE),

3188

(SOFIA, CHEN), (AALIYA, YUKI), (FATOU, CHEN),

3189

3190

# Community users follow composer archive maintainers

3191

(GABRIEL, BACH), (SOFIA, BACH), (MARCUS, BACH),

3192

(CHEN, BACH), (AALIYA, BACH), (YUKI, BACH),

3193

(GABRIEL, CHOPIN), (AALIYA, CHOPIN), (SOFIA, CHOPIN),

3194

(MARCUS, SCOTT_JOPLIN), (GABRIEL, SCOTT_JOPLIN),

3195

(FATOU, SCOTT_JOPLIN),

3196

(CHEN, KEVIN_MACLEOD), (GABRIEL, KEVIN_MACLEOD),

3197

]

3198

# Deduplicate pairs so _uid collisions never cause constraint errors

3199

seen_follows: set[tuple[str, str]] = set()

3200

deduped_follows = []

3201

for pair in follow_pairs:

3202

if pair not in seen_follows:

3203

seen_follows.add(pair)

3204

deduped_follows.append(pair)

3205

for follower, followee in deduped_follows:

3206

db.add(MusehubFollow(

3207

follow_id=_uid(f"follow-{follower}-{followee}"),

3208

follower_id=follower,

3209

followee_id=followee,

3210

created_at=_now(days=15),

3211

))

3212

print(f" ✅ Follows: {len(deduped_follows)}")

await db.flush()

# ── 13. Watches ───────────────────────────────────────────────

3217

# 60+ total: community users watch each other's repos and the composer

3218

# archive repos they draw inspiration from.

3219

watch_pairs = [

3220

# Community repo watches

3221

(GABRIEL, REPO_AMBIENT), (GABRIEL, REPO_AFROBEAT), (GABRIEL, REPO_FUNK_SUITE),

3222

(GABRIEL, REPO_JAZZ_TRIO), (GABRIEL, REPO_GRANULAR), (GABRIEL, REPO_CHANSON),

3223

(GABRIEL, REPO_MICROTONAL), (GABRIEL, REPO_DRUM_MACHINE),

3224

3225

(SOFIA, REPO_NEO_SOUL), (SOFIA, REPO_FUNK_SUITE), (SOFIA, REPO_CHANSON),

3226

(SOFIA, REPO_MODAL_JAZZ), (SOFIA, REPO_AFROBEAT), (SOFIA, REPO_MICROTONAL),

3227

3228

(MARCUS, REPO_NEO_SOUL), (MARCUS, REPO_AMBIENT), (MARCUS, REPO_AFROBEAT),

3229

(MARCUS, REPO_MODAL_JAZZ), (MARCUS, REPO_JAZZ_TRIO), (MARCUS, REPO_FUNK_SUITE),

3230

3231

(YUKI, REPO_AMBIENT), (YUKI, REPO_GRANULAR), (YUKI, REPO_MICROTONAL),

3232

(YUKI, REPO_NEO_SOUL), (YUKI, REPO_DRUM_MACHINE),

3233

3234

(AALIYA, REPO_NEO_SOUL), (AALIYA, REPO_AFROBEAT), (AALIYA, REPO_FUNK_SUITE),

3235

(AALIYA, REPO_MODAL_JAZZ), (AALIYA, REPO_JAZZ_TRIO), (AALIYA, REPO_CHANSON),

3236

3237

(CHEN, REPO_MICROTONAL), (CHEN, REPO_AMBIENT), (CHEN, REPO_GRANULAR),

3238

(CHEN, REPO_MODAL_JAZZ), (CHEN, REPO_NEO_SOUL), (CHEN, REPO_DRUM_MACHINE),

3239

3240

(FATOU, REPO_AFROBEAT), (FATOU, REPO_DRUM_MACHINE),(FATOU, REPO_FUNK_SUITE),

3241

(FATOU, REPO_NEO_SOUL), (FATOU, REPO_MODAL_JAZZ), (FATOU, REPO_GRANULAR),

3242

3243

(PIERRE, REPO_CHANSON), (PIERRE, REPO_AMBIENT), (PIERRE, REPO_NEO_SOUL),

3244

(PIERRE, REPO_MODAL_JAZZ), (PIERRE, REPO_MICROTONAL),

3245

3246

# Composer archive repo watches — community users watching source material

3247

(GABRIEL, REPO_GOLDBERG), (GABRIEL, REPO_WTC), (GABRIEL, REPO_NOCTURNES),

3248

(GABRIEL, REPO_MAPLE_LEAF), (GABRIEL, REPO_CIN_STRINGS),

3249

3250

(SOFIA, REPO_GOLDBERG), (SOFIA, REPO_WTC), (SOFIA, REPO_NOCTURNES),

3251

(MARCUS, REPO_MAPLE_LEAF), (MARCUS, REPO_GOLDBERG), (MARCUS, REPO_WTC),

3252

(AALIYA, REPO_NOCTURNES), (AALIYA, REPO_MAPLE_LEAF),

3253

(CHEN, REPO_CIN_STRINGS), (CHEN, REPO_GOLDBERG),

3254

(YUKI, REPO_WTC), (FATOU, REPO_MAPLE_LEAF), (PIERRE, REPO_NOCTURNES),

3255

3256

# Genre-fusion community repos

3257

(SOFIA, REPO_NEO_BAROQUE), (MARCUS, REPO_NEO_BAROQUE),

3258

(GABRIEL, REPO_JAZZ_CHOPIN), (MARCUS, REPO_RAGTIME_EDM),

3259

(GABRIEL, REPO_FILM_SCORE), (SOFIA, REPO_FILM_SCORE),

3260

(GABRIEL, REPO_COMMUNITY), (AALIYA, REPO_COMMUNITY),

3261

]

3262

for user_id, repo_id in watch_pairs:

3263

db.add(MusehubWatch(

3264

watch_id=_uid(f"watch-{user_id}-{repo_id}"),

3265

user_id=user_id,

3266

repo_id=repo_id,

3267

created_at=_now(days=10),

3268

))

3269

print(f" ✅ Watches: {len(watch_pairs)}")

await db.flush()

# ── 14. Notifications ─────────────────────────────────────────

3274

# 15-25 unread per user, all event types, all 8 users. 15-25 unread means

3275

# we create 20 notifications per user with the first 5 marked as read and

3276

# the remaining 15 unread — satisfying the "15-25 unread" spec.

3277

EVENT_TYPES = [

3278

"comment", "pr_opened", "pr_merged", "issue_opened", "new_commit",

3279

"new_follower", "star", "fork", "release", "watch",

3280

]

3281

NOTIFS_PER_USER = 20 # 5 read + 15 unread = 15 unread per user

3282

READ_THRESHOLD = 5 # first N are read

3283

all_repos_flat = [r["repo_id"] for r in (list(REPOS) + list(GENRE_REPOS))]

3284

notif_count = 0

3285

for i, (uid, uname, _) in enumerate(USERS):

3286

for j in range(NOTIFS_PER_USER):

3287

actor_user = USERS[(i + j + 1) % len(USERS)]

3288

db.add(MusehubNotification(

3289

notif_id=_uid(f"notif2-{uid}-{j}"),

3290

recipient_id=uid,

3291

event_type=EVENT_TYPES[j % len(EVENT_TYPES)],

3292

repo_id=all_repos_flat[(i + j) % len(all_repos_flat)],

3293

actor=actor_user[1],

3294

payload={"message": f"Notification {j + 1} for {uname}"},

3295

is_read=j < READ_THRESHOLD,

3296

created_at=_now(days=j),

3297

))

3298

notif_count += 1

3299

print(f" ✅ Notifications: {notif_count} ({NOTIFS_PER_USER - READ_THRESHOLD} unread per user)")

await db.flush()

# ── 15. Forks ─────────────────────────────────────────────────

3304

# Original community-to-community forks

3305

db.add(MusehubFork(

3306

fork_id=_uid("fork-neo-soul-marcus"),

3307

source_repo_id=REPO_NEO_SOUL,

3308

fork_repo_id=REPO_NEO_SOUL_FORK,

3309

forked_by="marcus",

3310

created_at=_now(days=10),

3311

))

3312

db.add(MusehubFork(

3313

fork_id=_uid("fork-ambient-yuki"),

3314

source_repo_id=REPO_AMBIENT,

3315

fork_repo_id=REPO_AMBIENT_FORK,

3316

forked_by="yuki",

3317

created_at=_now(days=5),

3318

))

3319

# Genre-archive → community forks: each community repo that remixes a

3320

# composer's archive is modelled as a fork of the canonical archive repo.

3321

# marcus/ragtime-edm ← scott_joplin/maple-leaf-rag

3322

db.add(MusehubFork(

3323

fork_id=_uid("fork-maple-leaf-marcus"),

3324

source_repo_id=REPO_MAPLE_LEAF,

3325

fork_repo_id=REPO_RAGTIME_EDM,

3326

forked_by="marcus",

3327

created_at=_now(days=30),

3328

))

3329

# aaliya/jazz-chopin ← chopin/nocturnes

3330

db.add(MusehubFork(

3331

fork_id=_uid("fork-nocturnes-aaliya"),

3332

source_repo_id=REPO_NOCTURNES,

3333

fork_repo_id=REPO_JAZZ_CHOPIN,

3334

forked_by="aaliya",

3335

created_at=_now(days=28),

3336

))

3337

# gabriel/neo-baroque ← bach/goldberg-variations

3338

db.add(MusehubFork(

3339

fork_id=_uid("fork-goldberg-gabriel-neobaroque"),

3340

source_repo_id=REPO_GOLDBERG,

3341

fork_repo_id=REPO_NEO_BAROQUE,

3342

forked_by="gabriel",

3343

created_at=_now(days=25),

3344

))

3345

# chen/film-score ← kevin_macleod/cinematic-strings

3346

db.add(MusehubFork(

3347

fork_id=_uid("fork-cinstrings-chen"),

3348

source_repo_id=REPO_CIN_STRINGS,

3349

fork_repo_id=REPO_FILM_SCORE,

3350

forked_by="chen",

3351

created_at=_now(days=22),

3352

))

3353

# gabriel/community-collab ← bach/goldberg-variations

3354

db.add(MusehubFork(

3355

fork_id=_uid("fork-goldberg-gabriel-community"),

3356

source_repo_id=REPO_GOLDBERG,

3357

fork_repo_id=REPO_COMMUNITY,

3358

forked_by="gabriel",

3359

created_at=_now(days=20),

))

print(" ✅ Forks: 7")

await db.flush()

# ── 16. View events (analytics) ───────────────────────────────

3366

# 1000+ total across all repos (community + genre archives). Each repo

3367

# receives 30 days of daily view fingerprints; active repos get up to 10

3368

# unique viewers per day, quieter repos get fewer.

3369

view_count = 0

3370

view_repos = list(REPOS) + list(GENRE_REPOS)

3371

for r in view_repos:

3372

repo_id = r["repo_id"]

3373

star_count = r.get("star_count", 5)

3374

for day_offset in range(30):

3375

date_str = (_now(days=day_offset)).strftime("%Y-%m-%d")

3376

viewers = max(star_count // 3 + 1, 3) # at least 3 unique viewers/day

3377

for v in range(min(viewers, 10)):

3378

try:

3379

db.add(MusehubViewEvent(

3380

view_id=_uid(f"view-{repo_id}-{day_offset}-{v}"),

3381

repo_id=repo_id,

3382

viewer_fingerprint=_sha(f"viewer-{repo_id}-{v}"),

3383

event_date=date_str,

3384

created_at=_now(days=day_offset),

))

view_count += 1

except Exception:

pass

print(f" ✅ View events: {view_count}")

await db.flush()

# ── 17. Download events ───────────────────────────────────────

3394

# 5-25 downloads per release tag across all repos. Using release_tags

3395

# (built in step 7) so every release gets at least 5 unique downloaders.

3396

all_user_ids = [u[0] for u in USERS]

3397

dl_count = 0

3398

dl_repos = list(REPOS) + list(GENRE_REPOS)

3399

for r in dl_repos:

3400

repo_id = r["repo_id"]

3401

tags = release_tags.get(repo_id, ["main"])

3402

if not tags:

3403

tags = ["main"]

3404

for ti, tag in enumerate(tags):

3405

# 5-15 downloads per release depending on tag index (older = more)

3406

n_downloads = max(5, 15 - ti * 2)

3407

for i in range(n_downloads):

3408

db.add(MusehubDownloadEvent(

3409

dl_id=_uid(f"dl2-{repo_id}-{tag}-{i}"),

3410

repo_id=repo_id,

3411

ref=tag,

3412

downloader_id=all_user_ids[i % len(all_user_ids)],

3413

created_at=_now(days=ti * 7 + i),

3414

))

3415

dl_count += 1

3416

print(f" ✅ Download events: {dl_count}")

3417

3418

# ── 17b. Webhooks + deliveries (1-3/repo, 10-20 deliveries each) ──────────

3419

WEBHOOK_CONFIGS: list[tuple[str, list[str]]] = [

3420

# (url_suffix, events)

3421

("push", ["push"]),

3422

("pr", ["pull_request", "push"]),

3423

("release", ["release", "push", "pull_request"]),

3424

]

3425

# Delivery outcome patterns: (response_status, success)

3426

# Mix of 200 OK, 500 server error, and 0 timeout

3427

DELIVERY_OUTCOMES: list[tuple[int, bool, str]] = [

3428

(200, True, '{"status": "ok"}'),

3429

(200, True, '{"accepted": true}'),

3430

(200, True, '{"queued": true}'),

3431

(500, False, '{"error": "Internal Server Error"}'),

3432

(500, False, '{"error": "Service unavailable"}'),

3433

(0, False, ""), # timeout — no response

3434

(200, True, '{"ok": 1}'),

3435

(404, False, '{"error": "Not Found"}'),

3436

(200, True, '{"received": true}'),

3437

(0, False, ""), # timeout

3438

]

3439

WEBHOOK_EVENT_TYPES = ["push", "pull_request", "release", "issue", "comment"]

webhook_count = 0

delivery_count = 0

for r in REPOS[:10]:

repo_id = r["repo_id"]

3445

# 1-3 webhooks per repo based on repo index

3446

repo_idx = REPOS.index(r)

3447

n_webhooks = 1 + (repo_idx % 3)

3448

for wh_i in range(n_webhooks):

3449

url_suffix, events = WEBHOOK_CONFIGS[wh_i % len(WEBHOOK_CONFIGS)]

3450

wh_id = _uid(f"webhook-{repo_id}-{wh_i}")

3451

db.add(MusehubWebhook(

3452

webhook_id=wh_id,

3453

repo_id=repo_id,

3454

url=f"https://hooks.example.com/{r['owner']}/{r['slug']}/{url_suffix}",

3455

events=events,

3456

secret=_sha(f"secret-{repo_id}-{wh_i}")[:32],

3457

active=True,

3458

created_at=_now(days=r["days_ago"] - 5),

3459

))

3460

webhook_count += 1

3461

# 10-20 deliveries per webhook

3462

n_deliveries = 10 + (abs(hash(wh_id)) % 11)

3463

for d_i in range(n_deliveries):

3464

outcome_idx = (abs(hash(wh_id)) + d_i) % len(DELIVERY_OUTCOMES)

3465

status, success, resp_body = DELIVERY_OUTCOMES[outcome_idx]

3466

evt = WEBHOOK_EVENT_TYPES[d_i % len(WEBHOOK_EVENT_TYPES)]

3467

db.add(MusehubWebhookDelivery(

3468

delivery_id=_uid(f"wh-delivery-{wh_id}-{d_i}"),

3469

webhook_id=wh_id,

3470

event_type=evt,

3471

payload=f'{{"event": "{evt}", "repo": "{repo_id}", "seq": {d_i}}}',

3472

attempt=1 + (d_i % 3),

3473

success=success,

3474

response_status=status,

3475

response_body=resp_body,

3476

delivered_at=_now(days=r["days_ago"] - d_i, hours=d_i % 24),

3477

))

3478

delivery_count += 1

3479

print(f" ✅ Webhooks: {webhook_count} Deliveries: {delivery_count}")

await db.flush()

# ── 17c. Render Jobs (async audio render pipeline) ─────────────────────────

3484

# Creates completed, processing, and failed render jobs across repos.

3485

# Each job ties a commit to a set of generated MP3/piano-roll artifact IDs.

3486

_RENDER_STATUSES = ["completed", "completed", "completed", "processing", "failed"]

3487

render_job_count = 0

3488

for r in all_repos[:16]: # Community + most popular genre archive repos

3489

repo_id = r["repo_id"]

3490

commits = all_commits.get(repo_id, [])

3491

if not commits:

3492

continue

3493

# 2-3 render jobs per repo (latest commits)

3494

target_commits = commits[-3:]

3495

for ji, c in enumerate(target_commits):

3496

rj_cid: str = c["commit_id"]

3497

rj_status: str = _RENDER_STATUSES[(abs(hash(repo_id)) + ji) % len(_RENDER_STATUSES)]

3498

err_msg = "Storpheus timeout after 30s" if rj_status == "failed" else None

3499

mp3_ids = (

3500

[f"sha256:{_sha(f'mp3-{rj_cid}-{i}')}" for i in range(3)]

3501

if rj_status == "completed" else []

3502

)

3503

img_ids = (

3504

[f"sha256:{_sha(f'img-{rj_cid}-{i}')}" for i in range(2)]

3505

if rj_status == "completed" else []

3506

)

3507

try:

3508

db.add(MusehubRenderJob(

3509

render_job_id=_uid(f"rjob-{repo_id}-{rj_cid[:12]}"),

repo_id=repo_id,

commit_id=rj_cid,

status=rj_status,

error_message=err_msg,

3514

midi_count=len(REPO_TRACKS.get(REPO_KEY_MAP.get(repo_id, "neo-soul"),

3515

REPO_TRACKS["neo-soul"])),

3516

mp3_object_ids=mp3_ids,

3517

image_object_ids=img_ids,

3518

created_at=_now(days=ji + 1),

3519

updated_at=_now(days=ji),

3520

))

3521

render_job_count += 1

3522

except Exception:

3523

pass # unique constraint on (repo_id, commit_id) — skip dupes

3524

print(f" ✅ Render jobs: {render_job_count}")

await db.flush()

# ── 17d. Activity Event Stream (musehub_events) ────────────────────────────

3529

# Captures the most recent activity on each repo: push, pr_open, pr_merge,

3530

# issue_open, issue_close, release, tag, session, fork, star events.

3531

_EVENT_TEMPLATES: list[tuple[str, str]] = [

3532

("push", "pushed {n} commits to {branch}"),

3533

("push", "force-pushed to {branch} (rebase)"),

3534

("pr_open", "opened pull request: {title}"),

3535

("pr_merge", "merged pull request into {branch}"),

3536

("pr_close", "closed pull request without merging"),

3537

("issue_open", "opened issue: {title}"),

3538

("issue_close", "closed issue #{n}"),

3539

("release", "published release {tag}"),

3540

("tag", "created tag {tag} at {branch}"),

3541

("session_start", "started recording session"),

3542

("session_end", "ended recording session — {n} commits"),

3543

("fork", "forked this repo"),

3544

("star", "starred this repo"),

3545

("branch_create", "created branch {branch}"),

3546

]

3547

_EVENT_ACTORS_POOL = list(ALL_CONTRIBUTORS)

3548

event_count = 0

3549

for r in all_repos:

3550

repo_id = r["repo_id"]

3551

commits = all_commits.get(repo_id, [])

3552

owner = r["owner"]

3553

actor_pool = [owner] * 3 + _EVENT_ACTORS_POOL # Weight owner higher

3554

# Generate 8-15 events per repo spread over the last 60 days

3555

n_events = 8 + abs(hash(repo_id)) % 8

3556

for ei in range(n_events):

3557

tmpl_type, tmpl_body = _EVENT_TEMPLATES[ei % len(_EVENT_TEMPLATES)]

3558

actor = actor_pool[(abs(hash(repo_id)) + ei) % len(actor_pool)]

3559

n_val = (ei % 10) + 1

3560

branch = "main" if ei % 3 == 0 else f"feat/{r['slug'][:20]}-{ei}"

3561

tag = f"v{ei // 3 + 1}.0.{'0' if ei % 2 == 0 else '1'}"

3562

description = (

3563

tmpl_body

3564

.replace("{n}", str(n_val))

3565

.replace("{branch}", branch)

3566

.replace("{title}", f"Issue/PR title for event {ei}")

3567

.replace("{tag}", tag)

3568

)

3569

meta: dict[str, object] = {

3570

"actor": actor,

3571

"branch": branch,

3572

"commit_count": n_val,

3573

}

3574

if commits and ei < len(commits):

3575

meta["commit_id"] = commits[ei]["commit_id"]

3576

db.add(MusehubEvent(

3577

event_id=_uid(f"event-{repo_id}-{ei}"),

3578

repo_id=repo_id,

3579

event_type=tmpl_type,

3580

actor=actor,

3581

description=description,

3582

event_metadata=meta,

3583

created_at=_now(days=60 - ei * 4, hours=ei * 3 % 24),

3584

))

3585

event_count += 1

3586

print(f" ✅ Events: {event_count}")

await db.flush()

# ── 18. Muse variations, phrases, note changes ────────────────

3591

# Collect stable commit hashes from the two most active repos as base

3592

# state IDs. muse_variations.base_state_id links a variation to the DAW

3593

# snapshot it was proposed against — we reuse musehub commit hashes as a

3594

# realistic stand-in for DAW project state hashes.

3595

neo_commits = all_commits.get(REPO_NEO_SOUL, [])

3596

jazz_commits = all_commits.get(REPO_MODAL_JAZZ, [])

3597

neo_hashes = [c["commit_id"] for c in neo_commits[-15:]] or [_sha("nb-fallback")]

3598

jazz_hashes = [c["commit_id"] for c in jazz_commits[-15:]] or [_sha("cc-fallback")]

3599

3600

var_nb, phrase_nb, nc_nb = _make_variation_section(

3601

project_id=PROJECT_NEO_BAROQUE,

3602

intents=VARIATION_INTENTS_NEO_BAROQUE,

3603

track_ids=TRACK_IDS_NEO_BAROQUE,

3604

region_ids=REGION_IDS_NEO_BAROQUE,

3605

base_commit_hashes=neo_hashes,

3606

seed_prefix="nb",

3607

)

3608

var_cc, phrase_cc, nc_cc = _make_variation_section(

3609

project_id=PROJECT_COMMUNITY_COLLAB,

3610

intents=VARIATION_INTENTS_COMMUNITY_COLLAB,

3611

track_ids=TRACK_IDS_COMMUNITY,

3612

region_ids=REGION_IDS_COMMUNITY,

3613

base_commit_hashes=jazz_hashes,

seed_prefix="cc",

)

all_variations = var_nb + var_cc

3618

all_phrases = phrase_nb + phrase_cc

3619

all_note_changes = nc_nb + nc_cc

3620

3621

for var in all_variations:

db.add(var)

await db.flush()

for ph in all_phrases:

db.add(ph)

await db.flush()

for nc in all_note_changes:

db.add(nc)

await db.flush()

print(f" ✅ Variations: {len(all_variations)} ({len(var_nb)} neo-baroque, {len(var_cc)} community-collab)")

3634

print(f" ✅ Phrases: {len(all_phrases)}")

3635

print(f" ✅ Note changes: {len(all_note_changes)}")

3636

# ── 19. Muse VCS — muse_objects, muse_snapshots, muse_commits, muse_tags ─

3637

#

3638

# Inserts content-addressed MIDI blobs, snapshot manifests, a proper DAG

3639

# of Muse commits (including merge commits), and the full tag taxonomy.

3640

#

3641

# Insertion order respects FK constraints:

3642

# muse_objects → muse_snapshots → muse_commits → muse_tags

#

muse_obj_count = 0

muse_snap_count = 0

muse_commit_count = 0

3647

muse_tag_count = 0

3648

3649

# Running objects pool so the same content can be deduplicated across

3650

# snapshots (object_ids that haven't changed reuse the same sha256).

3651

# Structure: repo_id → {filename: object_id}

3652

_prev_objects: dict[str, dict[str, str]] = {}

3653

3654

for r in REPOS:

3655

repo_id = r["repo_id"]

3656

hub_commits = all_commits.get(repo_id, [])

if not hub_commits:

continue

track_files = MUSE_VCS_FILES.get(repo_id, MUSE_VCS_FILES[REPO_AMBIENT])

3661

meta = MUSE_COMMIT_META.get(repo_id, MUSE_COMMIT_META[REPO_AMBIENT])

3662

is_rich = repo_id in MUSE_RICH_TAG_REPOS

3663

3664

prev_objects: dict[str, str] = {} # filename → object_id for this repo

3665

muse_commit_ids: list[str] = [] # ordered muse commit_ids for this repo

3666

3667

for i, hub_c in enumerate(hub_commits):

3668

snap_seed = f"snap-muse-{repo_id}-{i}"

3669

committed_at = hub_c["timestamp"]

3670

3671

# Build this commit's object set.

3672

# Every commit, ~2 files "change" (get fresh object_ids).

3673

# The rest reuse from the previous commit — simulating deduplication.

3674

changed_indices = {i % len(track_files), (i + 2) % len(track_files)}

3675

commit_objects: dict[str, str] = {}

3676

3677

for fi, (fname, base_size) in enumerate(track_files):

3678

if fi in changed_indices or fname not in prev_objects:

3679

# New or modified file → fresh content-addressed blob.

3680

obj_id = _sha(f"midi-{repo_id}-{fname}-v{i}")

3681

size = base_size + (i * 128) % 4096

3682

await db.execute(

3683

text(

3684

"INSERT INTO muse_objects (object_id, size_bytes, created_at)"

3685

" VALUES (:oid, :sz, :ca)"

3686

" ON CONFLICT (object_id) DO NOTHING"

3687

),

3688

{"oid": obj_id, "sz": size, "ca": committed_at},

)

muse_obj_count += 1

else:

# Unchanged file → reuse previous object_id (deduplication).

3693

obj_id = prev_objects[fname]

3694

commit_objects[fname] = obj_id

3695

3696

prev_objects = commit_objects

3697

3698

# Snapshot — manifest maps track paths to object_ids.

3699

snapshot_id = _sha(snap_seed)

3700

manifest: dict[str, str] = {f"tracks/{fname}": oid for fname, oid in commit_objects.items()}

3701

await db.execute(

3702

text(

3703

"INSERT INTO muse_snapshots (snapshot_id, manifest, created_at)"

3704

" VALUES (:sid, :manifest, :ca)"

3705

" ON CONFLICT (snapshot_id) DO NOTHING"

3706

),

3707

{"sid": snapshot_id, "manifest": json.dumps(manifest), "ca": committed_at},

)

muse_snap_count += 1

# Muse commit — derives its ID from snapshot + parent + message.

3712

parent_id: str | None = muse_commit_ids[-1] if muse_commit_ids else None

3713

# Merge commit every 7 commits (from commit 7 onward) — parent2 is the

3714

# commit from 5 positions back, simulating a merged feature branch.

3715

# Interval of 7 guarantees ≥5 merges per repo for repos with ≥35 commits.

3716

parent2_id: str | None = None

3717

if i >= 7 and i % 7 == 0 and len(muse_commit_ids) >= 6:

3718

parent2_id = muse_commit_ids[-6]

3719

3720

commit_id = _sha(f"muse-c-{snapshot_id}-{parent_id or ''}-{hub_c['message']}")

3721

await db.execute(

3722

text(

3723

"INSERT INTO muse_commits"

3724

" (commit_id, repo_id, branch, parent_commit_id, parent2_commit_id,"

3725

" snapshot_id, message, author, committed_at, created_at, metadata)"

3726

" VALUES"

3727

" (:cid, :rid, :branch, :pid, :p2id,"

3728

" :sid, :msg, :author, :cat, :cat, :meta)"

3729

" ON CONFLICT (commit_id) DO NOTHING"

),

{

"cid": commit_id,

"rid": repo_id,

"branch": hub_c["branch"],

"pid": parent_id,

"p2id": parent2_id,

"sid": snapshot_id,

"msg": hub_c["message"],

3739

"author": hub_c["author"],

3740

"cat": committed_at,

3741

"meta": json.dumps(meta),

3742

},

3743

)

3744

muse_commit_ids.append(commit_id)

3745

muse_commit_count += 1

3746

3747

# Tags: apply cycling taxonomy to every commit.

3748

# Rich repos get ALL taxonomy values; others get a representative subset.

3749

if is_rich:

3750

# Cycle through all 57 tag values across commits so every value appears.

3751

tag_val = _ALL_MUSE_TAGS[i % len(_ALL_MUSE_TAGS)]

3752

tag_vals = [tag_val]

3753

# Also add a second tag from a different category group.

3754

second_idx = (i + len(MUSE_EMOTION_TAGS)) % len(_ALL_MUSE_TAGS)

3755

if second_idx != i % len(_ALL_MUSE_TAGS):

3756

tag_vals.append(_ALL_MUSE_TAGS[second_idx])

3757

else:

3758

# Non-rich repos get one tag per commit drawn from a trimmed pool.

3759

_trimmed = MUSE_EMOTION_TAGS + MUSE_STAGE_TAGS + MUSE_GENRE_TAGS

3760

tag_vals = [_trimmed[i % len(_trimmed)]]

3761

3762

for tag_val in tag_vals:

3763

tag_id = _uid(f"muse-tag-{commit_id}-{tag_val}")

3764

await db.execute(

3765

text(

3766

"INSERT INTO muse_tags (tag_id, repo_id, commit_id, tag, created_at)"

3767

" VALUES (:tid, :rid, :cid, :tag, :ca)"

3768

" ON CONFLICT (tag_id) DO NOTHING"

3769

),

3770

{"tid": tag_id, "rid": repo_id, "cid": commit_id,

3771

"tag": tag_val, "ca": committed_at},

)

muse_tag_count += 1

_prev_objects[repo_id] = prev_objects

3776

3777

# Ensure every tag taxonomy value appears at least once in REPO_NEO_SOUL.

3778

# Walk through ALL values and seed any that haven't been covered yet.

3779

if all_commits.get(REPO_NEO_SOUL):

3780

hub_commits_ns = all_commits[REPO_NEO_SOUL]

3781

muse_ids_ns: list[str] = []

3782

for i, hub_c in enumerate(hub_commits_ns):

3783

snap_seed = f"snap-muse-{REPO_NEO_SOUL}-{i}"

3784

snapshot_id = _sha(snap_seed)

3785

parent_id_ns: str | None = muse_ids_ns[-1] if muse_ids_ns else None

3786

commit_id_ns = _sha(f"muse-c-{snapshot_id}-{parent_id_ns or ''}-{hub_c['message']}")

3787

muse_ids_ns.append(commit_id_ns)

3788

3789

# Fetch existing tags for REPO_NEO_SOUL.

3790

result = await db.execute(

3791

text("SELECT tag FROM muse_tags WHERE repo_id = :rid"),

3792

{"rid": REPO_NEO_SOUL},

3793

)

3794

existing_tags: set[str] = {row[0] for row in result.fetchall()}

3795

missing_tags = [t for t in _ALL_MUSE_TAGS if t not in existing_tags]

3796

3797

for j, missing_tag in enumerate(missing_tags):

3798

commit_id_ns = muse_ids_ns[j % len(muse_ids_ns)]

3799

committed_at_ns = hub_commits_ns[j % len(hub_commits_ns)]["timestamp"]

3800

tag_id = _uid(f"muse-tag-fill-{REPO_NEO_SOUL}-{missing_tag}")

3801

await db.execute(

3802

text(

3803

"INSERT INTO muse_tags (tag_id, repo_id, commit_id, tag, created_at)"

3804

" VALUES (:tid, :rid, :cid, :tag, :ca)"

3805

" ON CONFLICT (tag_id) DO NOTHING"

3806

),

3807

{"tid": tag_id, "rid": REPO_NEO_SOUL, "cid": commit_id_ns,

3808

"tag": missing_tag, "ca": committed_at_ns},

)

muse_tag_count += 1

await db.flush()

print(f" ✅ Muse objects: {muse_obj_count} blobs")

3814

print(f" ✅ Muse snapshots: {muse_snap_count} manifests")

3815

print(f" ✅ Muse commits: {muse_commit_count} (DAG; includes merge commits)")

3816

print(f" ✅ Muse tags: {muse_tag_count} (full taxonomy)")

await db.flush()

# ── 20. Usage Logs (billing history per user) ─────────────────────────────

3821

_USAGE_MODELS = ["anthropic/claude-sonnet-4.6", "anthropic/claude-opus-4.6"]

3822

_USAGE_PROMPTS = [

3823

"Add a counter-melody above the baroque theme",

3824

"Reharmonize the bridge using tritone substitutions",

3825

"Humanize the drum timing across all tracks",

3826

"Add string pad layer to the ambient section",

3827

"Transpose bass line down a perfect fifth",

3828

"Generate a jazz piano voicing for the IV chord",

3829

"Thicken the horns arrangement with parallel 3rds",

3830

"Reduce note density in bars 9-16 on the keys track",

3831

]

3832

usage_count = 0

3833

for uid, uname, _ in USERS: # Only community users generate usage

3834

n_logs = 8 + abs(hash(uid)) % 12 # 8-20 usage logs per user

3835

for li in range(n_logs):

3836

model = _USAGE_MODELS[li % len(_USAGE_MODELS)]

3837

prompt = _USAGE_PROMPTS[li % len(_USAGE_PROMPTS)]

3838

prompt_tok = 800 + abs(hash(uid + str(li))) % 1200

3839

compl_tok = 300 + abs(hash(uid + str(li) + "c")) % 800

3840

cost = (prompt_tok * 3 + compl_tok * 15) // 100 # ~cents approximation

3841

db.add(UsageLog(

3842

id=_uid(f"usage-{uid}-{li}"),

3843

user_id=uid,

3844

prompt=f"[{uname}] {prompt} (iteration {li + 1})",

3845

model=model,

3846

prompt_tokens=prompt_tok,

3847

completion_tokens=compl_tok,

3848

cost_cents=cost,

3849

created_at=_now(days=60 - li * 3),

3850

))

3851

usage_count += 1

3852

print(f" ✅ Usage logs: {usage_count}")

await db.flush()

# ── 21. Access Tokens (API key tracking) ──────────────────────────────────

3857

token_count = 0

3858

for uid, uname, _ in USERS:

3859

# 1-3 access tokens per user (active, revoked, expired)

3860

n_tokens = 1 + abs(hash(uid)) % 3

3861

for ti in range(n_tokens):

3862

is_revoked = ti > 0 and ti % 2 == 0

3863

db.add(AccessToken(

3864

id=_uid(f"token-{uid}-{ti}"),

3865

user_id=uid,

3866

token_hash=_sha(f"tok-{uid}-{ti}-secret"),

3867

expires_at=_now(days=-30 * ti) if is_revoked else _now(days=-365),

3868

revoked=is_revoked,

3869

created_at=_now(days=90 - ti * 15),

3870

))

3871

token_count += 1

3872

print(f" ✅ Access tokens: {token_count}")

await db.flush()

# ── 22. Conversations + Messages + Actions ────────────────────────────────

3877

_CONV_TITLES = [

3878

"Neo-Soul chord voicing session",

3879

"Ambient texture generation",

3880

"Jazz reharmonization experiment",

3881

"Drum groove exploration",

3882

"Counter-melody development",

3883

"Bridge arrangement help",

3884

"Mix balance discussion",

3885

"Modal jazz improvisation sketch",

3886

]

3887

_MSG_CONTENTS: list[tuple[str, str]] = [

3888

("user", "Can you add a counter-melody above the baroque theme in bars 9-16?"),

3889

("assistant", "I'll add a counter-melody that follows the harmonic rhythm of the baroque theme. The new voice will move in contrary motion to create interest."),

3890

("user", "Make the counter-melody more chromatic — use passing tones"),

3891

("assistant", "Adding chromatic passing tones between the structural chord tones. The counter-melody now has richer harmonic color while maintaining the baroque style."),

3892

("user", "What key is this section in?"),

3893

("assistant", "The section is in D Dorian — a natural minor mode built on D. The characteristic raised 6th (B natural) gives it the distinctive minor-but-not-sad quality."),

3894

("user", "Add a jazz-influenced harmony to the bridge"),

3895

("assistant", "I'll reharmonize the bridge using tritone substitutions on the dominant chords and quartal voicings on the tonic. This will give it a Coltrane-influenced quality."),

3896

]

3897

_ACTION_TYPES = ["generate_notes", "reharmonize", "transpose", "humanize", "analyze"]

conv_count = 0

msg_count = 0

action_count = 0

for uid, uname, _ in USERS:

3902

n_convs = 3 + abs(hash(uid)) % 4 # 3-7 conversations per user

3903

for ci in range(n_convs):

3904

conv_id = _uid(f"conv-{uid}-{ci}")

3905

title = _CONV_TITLES[(abs(hash(uid)) + ci) % len(_CONV_TITLES)]

3906

project_repo = all_repos[(abs(hash(uid)) + ci) % len(all_repos)]

db.add(Conversation(

id=conv_id,

user_id=uid,

project_id=project_repo["repo_id"],

3911

title=title,

3912

is_archived=ci == 0 and abs(hash(uid)) % 3 == 0,

3913

project_context={

3914

"repo_id": project_repo["repo_id"],

3915

"key_signature": project_repo.get("key_signature"),

3916

"tempo_bpm": project_repo.get("tempo_bpm"),

3917

},

3918

created_at=_now(days=30 - ci * 5),

3919

updated_at=_now(days=30 - ci * 5, hours=ci * 2),

3920

))

3921

conv_count += 1

3922

# 4-8 messages per conversation (user/assistant alternating)

3923

n_msgs = 4 + (abs(hash(conv_id)) % 5)

3924

prev_msg_id: str | None = None

3925

for mi in range(min(n_msgs, len(_MSG_CONTENTS))):

3926

role, content = _MSG_CONTENTS[mi]

3927

msg_id = _uid(f"msg-{conv_id}-{mi}")

3928

model_used = _USAGE_MODELS[mi % len(_USAGE_MODELS)] if role == "assistant" else None

3929

tok = {"prompt": 800 + mi * 50, "completion": 300 + mi * 30} if role == "assistant" else None

3930

db.add(ConversationMessage(

3931

id=msg_id,

3932

conversation_id=conv_id,

3933

role=role,

3934

content=content,

3935

model_used=model_used,

3936

tokens_used=tok,

3937

cost_cents=((tok["prompt"] * 3 + tok["completion"] * 15) // 100) if tok else 0,

3938

timestamp=_now(days=30 - ci * 5, hours=mi),

3939

))

3940

msg_count += 1

3941

# Add an action for assistant messages

3942

if role == "assistant" and mi > 0:

3943

action_type = _ACTION_TYPES[mi % len(_ACTION_TYPES)]

3944

db.add(MessageAction(

3945

id=_uid(f"action-{msg_id}"),

3946

message_id=msg_id,

3947

action_type=action_type,

3948

description=f"{action_type.replace('_', ' ').title()} performed on track",

3949

success=mi % 5 != 4, # Mostly successful

3950

error_message=None if mi % 5 != 4 else "Tool execution timeout",

3951

extra_metadata={"track": "keys", "bars": f"{mi * 8}-{mi * 8 + 8}"},

3952

timestamp=_now(days=30 - ci * 5, hours=mi),

))

action_count += 1

prev_msg_id = msg_id

print(f" ✅ Conversations: {conv_count} Messages: {msg_count} Actions: {action_count}")

await db.flush()

await db.commit()

print()

_print_urls(all_commits, session_ids, pr_ids, release_tags)

def _print_urls(

all_commits: dict[str, list[dict[str, Any]]] | None = None,

3967

session_ids: dict[str, list[str]] | None = None,

3968

pr_ids: dict[str, list[str]] | None = None,

3969

release_tags: dict[str, list[str]] | None = None,

3970

) -> None:

3971

"""Print all seeded MuseHub URLs to stdout for manual browser verification."""

3972

BASE = "http://localhost:10001/musehub/ui"

3973

print()

3974

print("=" * 72)

3975

print("🎵 MUSEHUB — ALL URLs (localhost:10001)")

3976

print("=" * 72)

3977

3978

print("\n── User profiles ────────────────────────────────────────────────")

3979

for _, uname, _ in list(USERS) + list(COMPOSER_USERS):

3980

print(f" {BASE}/users/{uname}")

3981

print(f" {BASE}/{uname} (redirects → above)")

3982

3983

print("\n── Explore / discover ───────────────────────────────────────────")

3984

print(f" {BASE}/explore")

3985

print(f" {BASE}/trending")

3986

print(f" {BASE}/search")

3987

print(f" {BASE}/feed")

3988

3989

all_repos_for_urls = list(REPOS[:8]) + list(GENRE_REPOS)

3990

for r in all_repos_for_urls: # Skip fork repos from URL dump

3991

owner, slug = r["owner"], r["slug"]

3992

repo_id = r["repo_id"]

3993

rbase = f"{BASE}/{owner}/{slug}"

3994

3995

print(f"\n── {owner}/{slug} ─────────────────────────────────────")

3996

print(f" Repo: {rbase}")

3997

print(f" Graph: {rbase}/graph")

3998

print(f" Timeline: {rbase}/timeline")

3999

print(f" Insights: {rbase}/insights")

4000

print(f" Credits: {rbase}/credits")

4001

print(f" Search: {rbase}/search")

4002

4003

if all_commits and repo_id in all_commits:

4004

commits = all_commits[repo_id]

4005

for c in commits[-3:]:

4006

print(f" Commit: {rbase}/commits/{c['commit_id'][:12]}")

4007

if commits:

4008

print(f" Diff: {rbase}/commits/{commits[-1]['commit_id'][:12]}/diff")

4009

4010

print(f" Issues: {rbase}/issues")

4011

print(f" PRs: {rbase}/pulls")

4012

print(f" Releases: {rbase}/releases")

4013

if release_tags and repo_id in release_tags:

4014

for tag in release_tags[repo_id]:

4015

print(f" {rbase}/releases/{tag}")

4016

print(f" Sessions: {rbase}/sessions")

4017

if session_ids and repo_id in session_ids:

4018

for sid in session_ids[repo_id][:2]:

4019

print(f" {rbase}/sessions/{sid}")

4020

print(f" Divergence:{rbase}/divergence")

4021

print(f" Context: {rbase}/context/main")

4022

print(f" Analysis: {rbase}/analysis/main/contour")

4023

print(f" {rbase}/analysis/main/tempo")

4024

print(f" {rbase}/analysis/main/dynamics")

print()

print("=" * 72)

print("✅ Seed complete.")

print("=" * 72)

async def main() -> None:

4033

"""CLI entry point. Pass --force to wipe existing seed data before re-seeding."""

4034

force = "--force" in sys.argv

4035

db_url: str = settings.database_url or ""

4036

engine = create_async_engine(db_url, echo=False)

4037

async_session = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False) # type: ignore[call-overload] # SQLAlchemy typing: sessionmaker + class_=AsyncSession overload not reflected in stubs

4038

async with async_session() as db:

4039

await seed(db, force=force)

4040

await engine.dispose()

4041

4042

4043

if __name__ == "__main__":

4044

asyncio.run(main())