scripts/seed_v2.py · gabriel/musehub

{"title": "Add Book II preludes (BWV 870-893)", "body": "Currently only Book I is encoded. Book II should be added systematically.", "state": "open", "labels": ["enhancement"]},

600

{"title": "Incorrect trill in Prelude No. 7 bar 3", "body": "The ornament should be a mordent (lower), not a trill starting from above.", "state": "closed", "labels": ["bug"]},

601

{"title": "Add MIDI velocity curve analysis", "body": "The dynamic profile across 35 bars could be visualized as a dimension plot.", "state": "open", "labels": ["enhancement", "analysis"]},

602

{"title": "Export to MusicXML format", "body": "Some users need MusicXML for notation software import.", "state": "open", "labels": ["feature-request"]},

603

{"title": "Parallel octaves in Fugue No. 5 bar 14", "body": "Voice-leading violation in the subject entry needs correction.", "state": "closed", "labels": ["bug"]},

604

],

605

REPO_V2_GYMNO: [

606

{"title": "Add Gymnopédie No. 2 and No. 3", "body": "Complete the set — No. 2 in C major and No. 3 in G major.", "state": "open", "labels": ["enhancement"]},

607

{"title": "Slow the tempo slightly — 48 BPM feels more authentic", "body": "Period recordings by Reinbert de Leeuw suggest 48-50 BPM.", "state": "open", "labels": ["discussion"]},

608

{"title": "Staccato on LH beat 1 breaking waltz feel", "body": "Beat 1 should be legatissimo, not staccato — reverting.", "state": "closed", "labels": ["bug"]},

609

{"title": "Add orchestral arrangement by Debussy", "body": "Debussy famously orchestrated Gymnopédie 1 and 3 — add as variant.", "state": "open", "labels": ["enhancement"]},

610

],

611

REPO_V2_NEO_SOUL: [

612

{"title": "Extend to 32 bars with bridge section", "body": "The groove needs a contrasting B-section — consider D major area.", "state": "open", "labels": ["enhancement"]},

613

{"title": "Add percussion variations — hi-hat pattern too repetitive", "body": "Bar 4 and 8 could have open hi-hat fills for variety.", "state": "open", "labels": ["enhancement"]},

614

{"title": "Rhodes voicing clashes with bass on bar 9", "body": "The A3 in the chord conflicts with the A2 bass note — revoice.", "state": "closed", "labels": ["bug"]},

615

{"title": "Export stems as individual tracks", "body": "Need separate MIDI files per instrument for DAW import.", "state": "open", "labels": ["feature-request"]},

616

{"title": "BPM feels rushed — try 88 BPM", "body": "Classic neo-soul sits at 85-90 BPM. 92 is slightly fast for this groove.", "state": "open", "labels": ["discussion"]},

617

],

618

REPO_V2_MUSE: [

619

{"title": "Add WebAssembly domain plugin", "body": "A Wasm plugin would let browser-native state versioning work without a server round-trip. The plugin interface is clean enough to support this.", "state": "open", "labels": ["enhancement", "performance"]},

620

{"title": "MIDI merge conflict on simultaneous pitch-bend edits in same track", "body": "When two branches each modify pitch_bend in the same bar, the three-way merge should use the OT delta algebra, but currently falls back to 'ours'. Steps to reproduce: muse checkout -b a; edit pitch bend bar 4; muse checkout main; edit pitch bend bar 4 differently; muse merge a.", "state": "open", "labels": ["bug"]},

621

{"title": "muse log --graph rendering breaks at 100+ commits", "body": "The ASCII graph renderer overflows the terminal at wide histories. This is a known issue in the graph module.", "state": "closed", "labels": ["bug"]},

622

{"title": "CRDT join is O(n²) for large note sequences", "body": "RGA merge in _crdt_notes.py iterates the full tombstone list for every insert. Should switch to a skip-list or B-tree for the tombstone index.", "state": "open", "labels": ["performance"]},

623

{"title": "Add support for ABC music notation format as a third domain", "body": "ABC notation is widely used in folk music. A domain plugin would let folk musicians use Muse.", "state": "open", "labels": ["feature-request"]},

624

{"title": "muse revert fails when parent commit has a CRDT merge", "body": "Reverting a commit that was produced by a CRDT join panics in the merge engine because the inverse delta cannot be computed for tombstoned notes.", "state": "closed", "labels": ["bug"]},

625

{"title": "Document the MuseDomainPlugin.schema() return type", "body": "The DomainSchema TypedDict is not fully documented — what keys are required vs optional? The plugin authoring guide is incomplete here.", "state": "open", "labels": ["docs"]},

626

],

627

REPO_V2_AGENTCEPTION: [

628

{"title": "Agent tree hangs when coordinator returns an empty plan", "body": "If the coordinator agent's LLM response parses to an empty PlanSpec (no phases), the orchestration loop spins indefinitely waiting for work items that never arrive.", "state": "closed", "labels": ["bug"]},

629

{"title": "Mission Control board doesn't update when PR is merged outside AgentCeption", "body": "If a PR is merged manually on GitHub (not via the MC merge button), the issue card stays in PR_OPEN state indefinitely until the next polling cycle (5 min).", "state": "open", "labels": ["bug"]},

630

{"title": "Add support for Claude claude-opus-4-6 as coordinator model", "body": "claude-opus-4-6 has a much larger context window which helps coordinators reason about full codebases. Should be selectable per-node in the org designer.", "state": "open", "labels": ["enhancement"]},

631

{"title": "Local LLM connection drops after 30 minutes of inactivity", "body": "When using LOCAL_LLM_PROVIDER=ollama, long-running worker agents lose their HTTP connection after idle timeout. Should retry with exponential backoff.", "state": "open", "labels": ["bug", "local-llm"]},

632

{"title": "Worker agents don't respect .gitattributes merge strategy", "body": "Workers create PRs that sometimes contain merge conflicts in files marked with 'merge=ours' in .gitattributes. The worktree setup doesn't configure the merge driver.", "state": "closed", "labels": ["bug"]},

633

{"title": "Add Muse VCS as an alternative backend to Git worktrees", "body": "Since AgentCeption and Muse are from the same author, it would be a natural fit to let agents commit to a Muse repo instead of a Git worktree. Would unlock multi-domain agent collaboration.", "state": "open", "labels": ["feature-request", "muse-integration"]},

634

{"title": "Cognitive architecture presets not persisted across container restarts", "body": "Custom org presets saved in the UI are stored in memory only. They should be written to the org-presets.yaml file or to the DB.", "state": "closed", "labels": ["bug"]},

635

],

636

REPO_V2_MUSEHUB_SRC: [

637

{"title": "Piano roll doesn't render MIDI files larger than 500KB", "body": "The /parse-midi endpoint times out on dense orchestral MIDI. Need streaming parse or a size-gated fast path.", "state": "open", "labels": ["bug", "performance"]},

638

{"title": "MCP resource musehub://trending returns 500 when no repos are starred", "body": "The trending query performs ORDER BY star_count DESC — if the result set is empty, the serializer raises AttributeError on a None row.", "state": "closed", "labels": ["bug"]},

639

{"title": "Domain install count doesn't decrement on uninstall", "body": "Calling DELETE /domains/{id}/install correctly removes the MusehubDomainInstall row but never decrements install_count on the domain row.", "state": "open", "labels": ["bug"]},

640

{"title": "Code domain symbol graph viewer not yet implemented", "body": "The @cgcardona/code domain declares viewer_type='symbol_graph' but the frontend only has piano_roll.html. Need a symbol_graph.html template + TypeScript renderer.", "state": "open", "labels": ["enhancement", "frontend"]},

641

{"title": "Search results don't include repo descriptions in the match", "body": "Full-text search only indexes repo name and tags. Descriptions should be included in the tsvector so searching 'multidimensional' finds relevant repos.", "state": "open", "labels": ["enhancement"]},

642

{"title": "elicitation tools silently fail when Mcp-Session-Id is missing", "body": "Interactive tools (compose planner, PR review) call ctx.elicit() which raises if no session exists, but the error is swallowed and the tool returns an empty response.", "state": "closed", "labels": ["bug"]},

],

}

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

647

# Git → Muse importer

648

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

649

650

# Source-code file extensions we store as Muse objects. Lock files, generated

651

# output, and binaries are excluded.

652

_CODE_INCLUDE_EXT = {

653

".py", ".pyi", ".ts", ".tsx", ".js", ".jsx", ".mjs",

654

".rs", ".go", ".rb", ".java", ".c", ".cpp", ".h", ".hpp", ".cs",

655

".kt", ".swift", ".sh", ".bash", ".zsh",

656

".md", ".rst", ".txt",

657

".toml", ".yaml", ".yml", ".json", ".ini", ".cfg", ".env.example",

658

".html", ".css", ".scss", ".sql",

659

}

660

661

_CODE_EXCLUDE_NAMES = {

662

"package-lock.json", "poetry.lock", "Cargo.lock", "yarn.lock",

663

"pnpm-lock.yaml", "Pipfile.lock", "composer.lock",

664

}

665

666

_CODE_EXCLUDE_DIRS = {

667

"node_modules", "__pycache__", ".git", "dist", "build",

668

".venv", "venv", ".mypy_cache", ".pytest_cache", ".ruff_cache",

669

"target", # Rust build artefacts

}

def _git_code_filter(path: str) -> bool:

674

"""Return True if this repo path should be stored as a Muse object."""

675

p = Path(path)

676

if p.name in _CODE_EXCLUDE_NAMES:

677

return False

678

if any(part in _CODE_EXCLUDE_DIRS for part in p.parts):

679

return False

680

return p.suffix in _CODE_INCLUDE_EXT

681

682

683

async def _import_github_repo(

db: AsyncSession,

r: dict[str, Any],

domain_id: str,

) -> tuple[int, int]:

688

"""Clone a GitHub repo, walk its full git DAG, and import into Muse.

689

690

For each git commit we create one MusehubCommit, preserving the real

691

message, author name, timestamp, and parent graph. HEAD file contents

692

are written to disk and linked as MusehubObjects.

693

694

Returns (commits_inserted, objects_inserted).

695

"""

696

repo_id = r["repo_id"]

697

github_url = r["github_url"]

698

max_commits: int | None = r.get("max_commits")

699

700

print(f" 🌐 Cloning {github_url}…", flush=True)

701

702

with tempfile.TemporaryDirectory() as tmpdir:

703

repo_path = Path(tmpdir) / "repo"

704

705

# Shallow-ish clone for big repos, full for small ones

706

depth_args = ["--depth", str(max_commits + 50)] if max_commits else []

707

clone = subprocess.run(

708

["git", "clone", "--quiet", "--no-single-branch"] + depth_args + [github_url, str(repo_path)],

709

capture_output=True, text=True, timeout=180,

710

)

711

if clone.returncode != 0:

712

print(f" ⚠️ Clone failed ({clone.stderr[:120].strip()}) — skipping {r['slug']}")

713

return 0, 0

714

715

def _git(*args: str) -> str:

716

return subprocess.run(

717

["git"] + list(args),

718

cwd=repo_path, capture_output=True, text=True, check=True,

719

).stdout.strip()

720

721

# ── Commit log (oldest → newest) ────────────────────────────────────

722

# %x1f = ASCII unit-separator — safe delimiter inside commit messages

723

raw_log = _git("log", "--format=%H\x1f%an\x1f%at\x1f%s", "--all", "--reverse")

724

commits_raw = [l for l in raw_log.split("\n") if l.strip()]

725

if max_commits:

726

commits_raw = commits_raw[:max_commits]

727

728

# ── Parent map ───────────────────────────────────────────────────────

729

parent_lines = _git("log", "--format=%H %P", "--all", "--reverse").split("\n")

730

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

731

for line in parent_lines:

732

parts = line.strip().split()

733

if parts:

734

parent_map[parts[0]] = parts[1:] if len(parts) > 1 else []

735

736

# ── Branch names + commit-to-branch map ─────────────────────────────

737

# Fetch both local and remote-tracking branches after a --no-single-branch clone.

738

branches_raw = _git("branch", "-a", "--format=%(refname:short)").split("\n")

739

branch_names_raw = [b.strip() for b in branches_raw if b.strip()]

740

# Normalise remote-tracking refs (origin/foo → foo), drop HEAD pointers

741

branch_names_set: set[str] = set()

742

for b in branch_names_raw:

743

if "HEAD" in b:

744

continue

745

b = b.removeprefix("origin/").removeprefix("remotes/origin/")

746

if b:

747

branch_names_set.add(b)

748

branch_names = list(branch_names_set) or ["main"]

749

750

try:

751

head_branch = _git("rev-parse", "--abbrev-ref", "HEAD") or "main"

752

except Exception:

753

head_branch = branch_names[0]

754

755

# Build a map: git_hash → branch name.

756

# For each branch, walk "git log <branch> --not <other_branches...>" to find

757

# commits exclusive to that branch; shared (merge-base) commits fall back to

758

# head_branch so every commit gets exactly one label.

759

print(f" 🔀 Mapping {len(branch_names)} branch(es)…", flush=True)

760

commit_branch_map: dict[str, str] = {}

761

for bname in branch_names:

762

try:

763

other_excludes = [f"^{ob}" for ob in branch_names if ob != bname]

764

branch_log = _git(

765

"log", f"origin/{bname}", "--format=%H",

766

*other_excludes,

767

)

768

for gh in branch_log.split("\n"):

769

gh = gh.strip()

770

if gh and gh not in commit_branch_map:

771

commit_branch_map[gh] = bname

772

except Exception:

773

pass # branch may not have a remote counterpart — fall through

774

775

# ── File objects — store HEAD files for main + all branch tips ───────

776

# We store the main HEAD plus unique files from each branch tip so that

777

# the diff viewer can show code for any branch.

778

print(f" 📁 Storing files (HEAD + branch tips)…", flush=True)

779

objects_count = 0

780

refs_to_store = ["HEAD"] + [f"origin/{b}" for b in branch_names if b != head_branch]

781

782

async def _store_files_at_ref(ref: str) -> int:

783

stored = 0

784

try:

785

file_list = _git("ls-tree", "-r", "--name-only", ref).split("\n")

786

except Exception:

787

return 0

788

for fpath in file_list:

789

fpath = fpath.strip()

790

if not fpath or not _git_code_filter(fpath):

791

continue

792

try:

793

blob = subprocess.run(

794

["git", "show", f"{ref}:{fpath}"],

795

cwd=repo_path, capture_output=True, timeout=10,

796

)

797

if blob.returncode != 0:

798

continue

799

content_bytes = blob.stdout

800

if len(content_bytes) > 300_000:

801

continue

802

803

obj_id = "sha256:" + hashlib.sha256(content_bytes).hexdigest()

804

ext = Path(fpath).suffix or ".txt"

805

dest = _objects_dir() / f"{obj_id.replace(':', '_')}{ext}"

806

if not dest.exists():

807

dest.write_bytes(content_bytes)

await db.execute(

text("""

INSERT INTO musehub_objects

812

(object_id, repo_id, path, size_bytes, disk_path, created_at)

813

VALUES (:oid, :rid, :path, :size, :dpath, now())

814

ON CONFLICT (object_id) DO NOTHING

815

"""),

816

{

817

"oid": obj_id, "rid": repo_id,

818

"path": fpath,

819

"size": len(content_bytes),

"dpath": str(dest),

},

)

stored += 1

except Exception:

pass

return stored

for ref in refs_to_store:

829

objects_count += await _store_files_at_ref(ref)

830

831

# ── Commit import ────────────────────────────────────────────────────

832

print(f" 📜 Importing {len(commits_raw)} commits…", flush=True)

833

git_to_muse: dict[str, str] = {}

834

commits_count = 0

835

last_commit_id: str | None = None

836

837

for line in commits_raw:

838

parts = line.split("\x1f", 3)

839

if len(parts) < 4:

840

continue

841

git_hash, author_name, timestamp_str, subject = parts

842

843

try:

844

ts = datetime.fromtimestamp(int(timestamp_str), tz=UTC)

845

except (ValueError, OverflowError, OSError):

846

ts = datetime.now(tz=UTC)

847

848

parent_git = parent_map.get(git_hash, [])

849

parent_muse = [git_to_muse[p] for p in parent_git if p in git_to_muse]

850

851

muse_cid = _sha(f"git-import-{repo_id}-{git_hash}")

852

git_to_muse[git_hash] = muse_cid

853

854

# Use the branch we mapped for this commit; fall back to head_branch

855

commit_branch = commit_branch_map.get(git_hash, head_branch)

await db.execute(

text("""

INSERT INTO musehub_commits

860

(commit_id, repo_id, branch, parent_ids, message, author, timestamp, snapshot_id)

861

VALUES (:cid, :rid, :branch, :parents, :msg, :author, :ts, :snap)

862

ON CONFLICT (commit_id) DO NOTHING

"""),

{

"cid": muse_cid,

"rid": repo_id,

"branch": commit_branch,

868

"parents": json.dumps(parent_muse),

869

"msg": subject[:1000],

870

"author": author_name[:120],

871

"ts": ts,

872

"snap": _sha(f"snap-git-{repo_id}-{git_hash}"),

873

},

874

)

875

last_commit_id = muse_cid

876

commits_count += 1

877

878

# ── Branches ─────────────────────────────────────────────────────────

879

for bname in branch_names:

880

try:

881

branch_head_git = _git("rev-parse", bname)

882

branch_head_muse = git_to_muse.get(branch_head_git, last_commit_id)

883

except Exception:

884

branch_head_muse = last_commit_id

if branch_head_muse:

await db.execute(

text("""

INSERT INTO musehub_branches

890

(branch_id, repo_id, name, head_commit_id)

891

VALUES (:bid, :rid, :name, :hcid)

892

ON CONFLICT (branch_id) DO UPDATE

893

SET head_commit_id = EXCLUDED.head_commit_id

894

"""),

895

{

896

"bid": _uid(f"branch-git-{repo_id}-{bname}"),

897

"rid": repo_id,

898

"name": bname,

899

"hcid": branch_head_muse,

},

)

print(

f" ✅ {commits_count} commits, {objects_count} objects "

905

f"({len(branch_names)} branch{'es' if len(branch_names) != 1 else ''})"

906

)

907

return commits_count, objects_count

908

909

910

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

911

# Disk storage helpers

912

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

913

914

def _objects_dir() -> Path:

915

d = Path(getattr(settings, "musehub_objects_dir", "/data/objects"))

916

d.mkdir(parents=True, exist_ok=True)

return d

def _write_midi_object(midi_bytes: bytes, repo_id: str, fname: str) -> tuple[str, Path]:

921

"""Write MIDI bytes to disk. Returns (object_id, disk_path)."""

922

obj_id = "sha256:" + hashlib.sha256(midi_bytes).hexdigest()

923

dest = _objects_dir() / f"{obj_id.replace(':', '_')}.mid"

924

if not dest.exists():

925

dest.write_bytes(midi_bytes)

return obj_id, dest

def _write_code_object(content: str, repo_id: str, fname: str) -> tuple[str, Path]:

930

"""Write source code text to disk. Returns (object_id, disk_path)."""

931

content_bytes = content.encode("utf-8")

932

obj_id = "sha256:" + hashlib.sha256(content_bytes).hexdigest()

933

ext = Path(fname).suffix or ".txt"

934

dest = _objects_dir() / f"{obj_id.replace(':', '_')}{ext}"

935

if not dest.exists():

936

dest.write_bytes(content_bytes)

return obj_id, dest

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

941

# Main seed function

942

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

943

944

async def _table_exists(db: AsyncSession, table: str) -> bool:

945

"""Return True if the given table exists in the public schema."""

946

result = await db.execute(

947

text(

948

"SELECT 1 FROM information_schema.tables "

949

"WHERE table_schema = 'public' AND table_name = :t"

),

{"t": table},

)

return result.fetchone() is not None

954

955

956

async def _safe_delete(db: AsyncSession, table: str, where_sql: str, params: dict) -> None:

957

"""Delete rows only if the table exists — silently skips if it does not."""

958

if await _table_exists(db, table):

959

await db.execute(text(f"DELETE FROM {table} WHERE {where_sql}"), params)

960

961

962

async def seed(db: AsyncSession) -> None:

963

print("\n🌱 MuseHub V2 seed — domain-agnostic multi-dimensional showcase")

964

print("=" * 60)

965

966

# ── 0. Pre-flight: verify the V2 migration has been applied ───────────

967

if not await _table_exists(db, "musehub_domains"):

968

print()

969

print(" ❌ ERROR: musehub_domains table does not exist.")

970

print(" Run the V2 Alembic migration first:")

971

print()

972

print(" docker compose exec musehub alembic upgrade head")

973

print()

974

print(" Then re-run this script.")

print()

raise SystemExit(1)

# ── 1. Wipe V2 data if --force ────────────────────────────────────────

979

if FORCE:

980

print(" ⚠️ --force: wiping V2 rows…")

981

for repo_id in ([r["repo_id"] for r in MIDI_REPOS] +

982

[r["repo_id"] for r in CODE_REPOS]):

983

await _safe_delete(db, "musehub_repos", "repo_id = :rid", {"rid": repo_id})

984

# Delete by stable author/slug rather than potentially-mismatched IDs

985

await _safe_delete(

986

db, "musehub_domain_installs",

987

"domain_id IN (SELECT domain_id FROM musehub_domains "

988

"WHERE author_slug='cgcardona' AND slug IN ('midi','code'))",

{},

)

await _safe_delete(

db, "musehub_domains",

993

"author_slug='cgcardona' AND slug IN ('midi','code')",

{},

)

await db.flush()

print(" ✅ V2 rows cleared")

998

999

# ── 2. Domain registry ────────────────────────────────────────────────

1000

print("\n 📦 Domain registry…")

1001

_midi_caps_json = json.dumps(_MIDI_CAPS, sort_keys=True)

1002

_code_caps_json = json.dumps(_CODE_CAPS, sort_keys=True)

1003

midi_hash = hashlib.sha256(_midi_caps_json.encode()).hexdigest()

1004

code_hash = hashlib.sha256(_code_caps_json.encode()).hexdigest()

1005

1006

for stable_id, author_slug, slug, display, desc, caps, hash_, viewer, install_count in [

1007

(DOMAIN_MIDI, "cgcardona", "midi", "MIDI",

1008

"21-dimensional MIDI state versioning. Tracks harmonic, rhythmic, melodic, structural, "

1009

"dynamic, timbral, spatial, textural, pedal, microtonal, and 11 more dimensions. "

1010

"Piano roll viewer. OT merge semantics. Supports piano, orchestra, electronic, and any MIDI instrument.",

1011

_MIDI_CAPS, midi_hash, "piano_roll", len(MIDI_REPOS)),

1012

(DOMAIN_CODE, "cgcardona", "code", "Code",

1013

"10-language symbol-graph code versioning. Tracks syntax, semantics, types, tests, docs, "

1014

"complexity, dependencies, security, performance, and style dimensions. "

1015

"Symbol graph viewer. Three-way merge. Python, TypeScript, Rust, Go, and more.",

1016

_CODE_CAPS, code_hash, "symbol_graph", len(CODE_REPOS)),

1017

]:

1018

# Try inserting with the stable ID; if the migration already seeded a row

1019

# with a different ID, the ON CONFLICT on (author_slug, slug) will update

1020

# the metadata but keep whatever ID is already there.

1021

await db.execute(

1022

text("""

1023

INSERT INTO musehub_domains

1024

(domain_id, author_slug, slug, display_name, description, version,

1025

manifest_hash, capabilities, viewer_type, install_count, is_verified, created_at, updated_at)

1026

VALUES

1027

(:did, :author, :slug, :name, :desc, '2.0.0',

1028

:hash, CAST(:caps AS jsonb), :viewer, :installs, true, now(), now())

1029

ON CONFLICT (author_slug, slug) DO UPDATE

1030

SET manifest_hash = EXCLUDED.manifest_hash,

1031

capabilities = EXCLUDED.capabilities,

1032

install_count = EXCLUDED.install_count,

1033

version = EXCLUDED.version,

updated_at = now()

"""),

{

"did": stable_id, "author": author_slug, "slug": slug,

1038

"name": display, "desc": desc, "hash": hash_,

1039

"caps": json.dumps(caps), "viewer": viewer, "installs": install_count,

},

)

await db.flush()

# Resolve the actual domain_ids from the DB — the migration may have seeded

1045

# with different UUIDs; we join by (author_slug, slug) which is the stable key.

1046

row_midi = (await db.execute(

1047

text("SELECT domain_id FROM musehub_domains WHERE author_slug='cgcardona' AND slug='midi'")

1048

)).fetchone()

1049

row_code = (await db.execute(

1050

text("SELECT domain_id FROM musehub_domains WHERE author_slug='cgcardona' AND slug='code'")

1051

)).fetchone()

1052

1053

if not row_midi or not row_code:

1054

raise RuntimeError("Domain registry insert failed — rows not found after upsert.")

1055

1056

actual_midi_id = row_midi[0]

1057

actual_code_id = row_code[0]

1058

1059

print(f" ✅ @cgcardona/midi → {actual_midi_id}")

1060

print(f" ✅ @cgcardona/code → {actual_code_id}")

1061

1062

# ── 3. MIDI showcase repos ────────────────────────────────────────────

1063

print("\n 🎹 MIDI showcase repos…")

1064

midi_repo_count = 0

1065

midi_object_count = 0

1066

midi_commit_count = 0

1067

1068

for r in MIDI_REPOS:

1069

repo_id = r["repo_id"]

1070

1071

# Check idempotency

1072

existing = await db.execute(

1073

text("SELECT 1 FROM musehub_repos WHERE repo_id = :rid"), {"rid": repo_id}

1074

)

1075

if existing.fetchone() and not FORCE:

1076

print(f" ⏭ {r['owner']}/{r['slug']} exists — skipping")

continue

# Insert repo

await db.execute(

text("""

INSERT INTO musehub_repos

1083

(repo_id, owner, owner_user_id, slug, name, description, visibility,

1084

tags, domain_id, domain_meta, created_at)

1085

VALUES

1086

(:rid, :owner, :uid, :slug, :name, :desc, :vis,

1087

CAST(:tags AS json), :did, CAST(:dmeta AS json), :created)

1088

ON CONFLICT (repo_id) DO NOTHING

1089

"""),

1090

{

1091

"rid": repo_id, "owner": r["owner"], "uid": r["owner_user_id"],

1092

"slug": r["slug"], "name": r["name"], "desc": r["description"],

1093

"vis": r["visibility"],

1094

"did": actual_midi_id, "dmeta": json.dumps(r["domain_meta"]),

1095

"tags": json.dumps(r["tags"]),

1096

"created": _now(days=r["days_ago"]),

},

)

midi_repo_count += 1

# Generate and write MIDI files

1102

for fname, gen_key in r["midi_files"]:

1103

try:

1104

midi_bytes = MIDI_GENERATORS[gen_key]()

1105

except Exception as exc:

1106

print(f" ⚠️ MIDI generation failed for {gen_key}: {exc}")

midi_bytes = b""

if midi_bytes:

obj_id, disk_path = _write_midi_object(midi_bytes, repo_id, fname)

1111

await db.execute(

1112

text("""

1113

INSERT INTO musehub_objects (object_id, repo_id, path, size_bytes, disk_path, created_at)

1114

VALUES (:oid, :rid, :path, :size, :dpath, now())

1115

ON CONFLICT (object_id) DO NOTHING

1116

"""),

1117

{

1118

"oid": obj_id, "rid": repo_id,

1119

"path": f"tracks/{fname}",

1120

"size": len(midi_bytes),

1121

"dpath": str(disk_path),

1122

},

1123

)

1124

midi_object_count += 1

1125

1126

# Commits

1127

commit_templates = _MIDI_COMMITS.get(repo_id, [])

1128

prev_commit: str | None = None

1129

for i, (msg, author) in enumerate(commit_templates):

1130

cid = _sha(f"v2-midi-commit-{repo_id}-{i}")

1131

days = max(0, r["days_ago"] - i * 3)

1132

await db.execute(

1133

text("""

1134

INSERT INTO musehub_commits

1135

(commit_id, repo_id, branch, parent_ids, message, author, timestamp, snapshot_id)

1136

VALUES (:cid, :rid, 'main', :parents, :msg, :author, :ts, :snap)

1137

ON CONFLICT (commit_id) DO NOTHING

1138

"""),

1139

{

1140

"cid": cid, "rid": repo_id,

1141

"parents": json.dumps([prev_commit] if prev_commit else []),

1142

"msg": msg, "author": author,

1143

"ts": _now(days=days),

1144

"snap": _sha(f"snap-v2-{repo_id}-{i}"),

},

)

prev_commit = cid

midi_commit_count += 1

# Main branch

if prev_commit:

await db.execute(

text("""

INSERT INTO musehub_branches (branch_id, repo_id, name, head_commit_id)

1155

VALUES (:bid, :rid, 'main', :hcid)

1156

ON CONFLICT (branch_id) DO UPDATE SET head_commit_id = EXCLUDED.head_commit_id

1157

"""),

1158

{"bid": _uid(f"branch-v2-{repo_id}-main"), "rid": repo_id, "hcid": prev_commit},

1159

)

1160

1161

# Stars from community

1162

for j, uname in enumerate(ALL_CONTRIBUTORS[:min(r["star_count"] % 8 + 3, 8)]):

1163

uid = f"user-{uname.lower()}-00" + str(j + 1).zfill(4)[-2:]

1164

await db.execute(

1165

text("INSERT INTO musehub_stars (star_id, repo_id, user_id, created_at) VALUES (:sid, :rid, :uid, now()) ON CONFLICT (star_id) DO NOTHING"),

1166

{"sid": _uid(f"star-v2-{repo_id}-{uname}"), "rid": repo_id, "uid": uid},

1167

)

1168

1169

print(f" ✅ {r['owner']}/{r['slug']}")

1170

1171

await db.flush()

1172

print(f"\n ✅ MIDI: {midi_repo_count} repos, {midi_object_count} .mid files, {midi_commit_count} commits")

1173

1174

# ── 4. Code domain repos — imported from real GitHub repos ───────────

1175

print("\n 💻 Code domain repos (cloning from GitHub…)")

1176

code_repo_count = 0

1177

code_object_count = 0

1178

code_commit_count = 0

1179

1180

for r in CODE_REPOS:

1181

repo_id = r["repo_id"]

1182

print(f"\n ▶ {r['owner']}/{r['slug']}", flush=True)

1183

1184

existing = await db.execute(

1185

text("SELECT 1 FROM musehub_repos WHERE repo_id = :rid"), {"rid": repo_id}

1186

)

1187

if existing.fetchone() and not FORCE:

1188

print(f" ⏭ exists — skipping")

1189

continue

1190

1191

# Create the repo row

1192

await db.execute(

1193

text("""

1194

INSERT INTO musehub_repos

1195

(repo_id, owner, owner_user_id, slug, name, description, visibility,

1196

tags, domain_id, domain_meta, created_at)

1197

VALUES

1198

(:rid, :owner, :uid, :slug, :name, :desc, :vis,

1199

CAST(:tags AS json), :did, CAST(:dmeta AS json), :created)

1200

ON CONFLICT (repo_id) DO NOTHING

1201

"""),

1202

{

1203

"rid": repo_id, "owner": r["owner"], "uid": r["owner_user_id"],

1204

"slug": r["slug"], "name": r["name"], "desc": r["description"],

1205

"vis": r["visibility"],

1206

"did": actual_code_id, "dmeta": json.dumps(r["domain_meta"]),

1207

"tags": json.dumps(r["tags"]),

1208

"created": _now(days=r["days_ago"]),

},

)

code_repo_count += 1

# Clone the real GitHub repo and import its full git history

1214

n_commits, n_objects = await _import_github_repo(db, r, actual_code_id)

1215

code_commit_count += n_commits

1216

code_object_count += n_objects

1217

1218

# Stars

1219

for j, uname in enumerate(ALL_CONTRIBUTORS[:min(r["star_count"] % 8 + 2, 8)]):

1220

uid_num = str(j + 1).zfill(3)

1221

await db.execute(

1222

text("INSERT INTO musehub_stars (star_id, repo_id, user_id, created_at) VALUES (:sid, :rid, :uid, now()) ON CONFLICT (star_id) DO NOTHING"),

1223

{"sid": _uid(f"star-v2-code-{repo_id}-{uname}"), "rid": repo_id,

1224

"uid": _uid(f"user-{uname}-{uid_num}")},

)

await db.flush()

print(f"\n ✅ Code: {code_repo_count} repos, {code_object_count} source files, {code_commit_count} commits")

1229

1230

# ── 5. Issues for all V2 repos ────────────────────────────────────────

1231

print("\n 🐛 Issues…")

1232

issue_count = 0

1233

all_v2_repos = MIDI_REPOS + CODE_REPOS

1234

1235

for r in all_v2_repos:

1236

repo_id = r["repo_id"]

1237

issue_list = _ISSUES.get(repo_id, [])

1238

for i, iss in enumerate(issue_list):

1239

issue_id = _uid(f"issue-v2-{repo_id}-{i}")

1240

await db.execute(

1241

text("""

1242

INSERT INTO musehub_issues

1243

(issue_id, repo_id, number, title, body, state, author, created_at, updated_at)

1244

VALUES (:iid, :rid, :num, :title, :body, :state, :author, :ts, :ts)

1245

ON CONFLICT (issue_id) DO NOTHING

1246

"""),

1247

{

1248

"iid": issue_id, "rid": repo_id,

1249

"num": i + 1, "title": iss["title"],

1250

"body": iss["body"], "state": iss["state"],

1251

"author": r["owner"],

1252

"ts": _now(days=r["days_ago"] - i * 5),

},

)

issue_count += 1

await db.flush()

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

1259

1260

# ── 6. Pull requests ──────────────────────────────────────────────────

1261

print("\n 🔀 Pull requests…")

1262

pr_count = 0

1263

1264

_PR_TEMPLATES: list[dict[str, str]] = [

1265

{"title": "feat: add extended 32-bar variation", "body": "Extends the main loop with a contrasting B-section.", "state": "open"},

1266

{"title": "fix: velocity humanization — beat 1 accent corrected", "body": "Beat 1 was not receiving the +12 velocity boost.", "state": "merged"},

1267

{"title": "feat: orchestral arrangement variant", "body": "Full orchestra version derived from the solo piano base.", "state": "merged"},

1268

{"title": "refactor: split into individual track objects", "body": "Separates each instrument into its own .mid file for DAW import.", "state": "open"},

1269

]

1270

for r in all_v2_repos:

1271

for i, pr_tmpl in enumerate(_PR_TEMPLATES[:3]):

1272

pr_id = _uid(f"pr-v2-{r['repo_id']}-{i}")

1273

author = ALL_CONTRIBUTORS[(i + hash(r["repo_id"])) % len(ALL_CONTRIBUTORS)]

1274

ts = _now(days=r["days_ago"] - i * 7 - 3)

1275

is_merged = pr_tmpl["state"] == "merged"

1276

await db.execute(

1277

text("""

1278

INSERT INTO musehub_pull_requests

1279

(pr_id, repo_id, title, body, state, author,

1280

from_branch, to_branch, created_at, merged_at)

1281

VALUES (:pid, :rid, :title, :body, :state, :author,

1282

:head, 'main', :ts, :merged_at)

1283

ON CONFLICT (pr_id) DO NOTHING

1284

"""),

1285

{

1286

"pid": pr_id, "rid": r["repo_id"],

1287

"title": pr_tmpl["title"],

1288

"body": pr_tmpl["body"], "state": pr_tmpl["state"],

1289

"author": author,

1290

"head": f"feat/v2-extension-{i}",

1291

"ts": ts,

1292

"merged_at": ts if is_merged else None,

},

)

pr_count += 1

await db.flush()

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

1299

1300

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

1301

print("\n 🏷 Releases…")

1302

rel_count = 0

1303

for r in all_v2_repos:

1304

for v_major, v_minor, days_offset in [(1, 0, 10), (1, 1, 5), (2, 0, 1)]:

1305

rel_id = _uid(f"release-v2-{r['repo_id']}-{v_major}-{v_minor}")

1306

tag = f"v{v_major}.{v_minor}"

1307

await db.execute(

1308

text("""

1309

INSERT INTO musehub_releases

1310

(release_id, repo_id, tag, title, body, author,

1311

is_prerelease, is_draft, created_at)

1312

VALUES (:rid, :repo, :tag, :title, :body, :author,

1313

false, false, :ts)

1314

ON CONFLICT (release_id) DO NOTHING

1315

"""),

1316

{

1317

"rid": rel_id, "repo": r["repo_id"],

1318

"tag": tag, "title": f"{r['name']} {tag}",

1319

"body": f"Release {tag} — see commit log for changes.",

1320

"author": r["owner"],

1321

"ts": _now(days=days_offset),

},

)

rel_count += 1

await db.flush()

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

1328

1329

# ── 8. Muse VCS layer (muse_objects + muse_snapshots + muse_commits) ──

1330

print("\n 🔗 Muse VCS layer…")

1331

vcs_commit_count = 0

1332

1333

for r in all_v2_repos:

1334

repo_id = r["repo_id"]

1335

commits = _MIDI_COMMITS.get(repo_id) or []

1336

prev_muse_id: str | None = None

1337

1338

for i, (msg, author) in enumerate(commits):

1339

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

1340

snap_id = _sha(snap_seed)

1341

committed_at = _now(days=max(0, r["days_ago"] - i * 2))

1342

1343

# Snapshot manifest — minimal for VCS graph

1344

manifest = {f"state/{i:04d}.dat": _sha(f"obj-v2-{repo_id}-{i}")}

1345

await db.execute(

1346

text("""

1347

INSERT INTO muse_snapshots (snapshot_id, manifest, created_at)

1348

VALUES (:sid, :manifest, :ca)

1349

ON CONFLICT (snapshot_id) DO NOTHING

1350

"""),

1351

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

1352

)

1353

1354

parent2: str | None = None

1355

if i >= 7 and i % 7 == 0 and prev_muse_id:

1356

# Merge commit — grab commit 6 back

1357

parent2 = _sha(f"muse-c-v2-{_sha(f'muse-snap-v2-{repo_id}-{max(0, i-6)}')}")

1358

1359

commit_id = _sha(f"muse-c-v2-{snap_id}-{prev_muse_id or ''}-{msg}")

1360

await db.execute(

1361

text("""

1362

INSERT INTO muse_commits

1363

(commit_id, repo_id, branch, parent_commit_id, parent2_commit_id,

1364

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

1365

VALUES

1366

(:cid, :rid, 'main', :pid, :p2id,

1367

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

1368

ON CONFLICT (commit_id) DO NOTHING

1369

"""),

1370

{

1371

"cid": commit_id, "rid": repo_id, "pid": prev_muse_id, "p2id": parent2,

1372

"sid": snap_id, "msg": msg, "author": author, "cat": committed_at,

1373

"meta": json.dumps(r.get("domain_meta", {})),

1374

},

1375

)

1376

prev_muse_id = commit_id

1377

vcs_commit_count += 1

1378

1379

await db.flush()

1380

print(f" ✅ Muse commits: {vcs_commit_count}")

1381

1382

# ── 9. Domain installs ────────────────────────────────────────────────

1383

print("\n 📥 Domain installs…")

1384

install_count = 0

1385

user_ids = {

1386

"gabriel": GABRIEL, "sofia": SOFIA, "marcus": MARCUS, "yuki": YUKI,

1387

"aaliya": AALIYA, "chen": CHEN, "fatou": FATOU, "pierre": PIERRE,

1388

}

1389

for r in MIDI_REPOS:

1390

uid = user_ids.get(r["owner"])

if uid:

await db.execute(

text("""

INSERT INTO musehub_domain_installs (install_id, user_id, domain_id, created_at)

1395

VALUES (:iid, :uid, :did, now())

1396

ON CONFLICT (install_id) DO NOTHING

1397

"""),

1398

{"iid": _uid(f"install-v2-midi-{uid}"), "uid": uid, "did": actual_midi_id},

)

install_count += 1

for r in CODE_REPOS:

uid = user_ids.get(r["owner"])

if uid:

await db.execute(

text("""

INSERT INTO musehub_domain_installs (install_id, user_id, domain_id, created_at)

1407

VALUES (:iid, :uid, :did, now())

1408

ON CONFLICT (install_id) DO NOTHING

1409

"""),

1410

{"iid": _uid(f"install-v2-code-{uid}"), "uid": uid, "did": actual_code_id},

)

install_count += 1

await db.flush()

print(f" ✅ Domain installs: {install_count}")

1416

1417

print("\n" + "=" * 60)

1418

print("🎉 MuseHub V2 seed complete!")

1419

print(f" Domains: 2 (@cgcardona/midi, @cgcardona/code)")

1420

print(f" MIDI repos: {midi_repo_count} (with playable .mid files)")

1421

print(f" Code repos: {code_repo_count} (with real source files)")

1422

print(f" VCS commits: {vcs_commit_count}")

1423

print(f" Issues/PRs: {issue_count}/{pr_count}")

1424

print(f" Releases: {rel_count}")

print()

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

1429

# Entry point

1430

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

1431

1432

async def main() -> None:

1433

engine = create_async_engine(settings.database_url, echo=False)

1434

async_session = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)

1435

1436

async with async_session() as session:

1437

async with session.begin():

1438

await seed(session)

1439

1440

await engine.dispose()

1441

1442

1443

if __name__ == "__main__":

1444

asyncio.run(main())