Merge pull request #155 from TwDover/feat/hum-to-melody

feat/hum-to-melody

Author: TwDover

.claude/skills/run-genregrid/scenarios/hum-melody-ui.mjs

@@ -0,0 +1,102 @@
+/*
+ * Roadmap 8.2 UI check: switch to Full Song mode, open the Advanced details
+ * section, and confirm the new "…or hum/whistle it" field renders alongside
+ * the existing melody/groove import rows. Real mic capture can't be driven
+ * headlessly, so this only verifies the DOM + a click on "● Rec" doesn't throw
+ * (a permission-denied error in this environment is expected and fine).
+ *
+ * `gg` = { evaluate, screenshot, waitReady, raw(method,params), sleep }.
+ */
+export default async function (gg) {
+  await gg.evaluate(`
+    const b = [...document.querySelectorAll('button')].find(b => b.textContent.trim().endsWith('Setup'));
+    if (b) b.click();
+    return !!b;
+  `);
+  await gg.sleep(400);
+
+  const afterSetupClick = await gg.evaluate(`
+    const sheet = document.querySelector('.sheet-top');
+    return { className: sheet ? sheet.className : null };
+  `);
+  console.log('AFTER_SETUP_CLICK', JSON.stringify(afterSetupClick));
+
+  const switched = await gg.evaluate(`
+    const byTitle = (t) => [...document.querySelectorAll('.mc-title')].find(s => s.textContent.trim() === t);
+    const el = byTitle('Full Song');
+    if (el) { el.closest('button').click(); return true; }
+    return false;
+  `);
+  await gg.sleep(400);
+
+  const opened = await gg.evaluate(`
+    const form = document.querySelector('.song-form');
+    if (!form) return false;
+    const summary = [...form.querySelectorAll('summary')].find(s => s.textContent.includes('Advanced'));
+    if (summary) { summary.closest('details').open = true; return true; }
+    return false;
+  `);
+  await gg.sleep(300);
+
+  const before = await gg.evaluate(`
+    const form = document.querySelector('.song-form');
+    const fields = form ? [...form.querySelectorAll('.field label')].map(l => l.textContent.trim().slice(0, 80)) : [];
+    const recBtn = form ? [...form.querySelectorAll('.melody-row button')].find(b => b.textContent.includes('Rec')) : null;
+    return { hasSongForm: !!form, fields, hasRecBtn: !!recBtn, recBtnText: recBtn ? recBtn.textContent.trim() : null };
+  `);
+
+  await gg.evaluate(`
+    const label = [...document.querySelectorAll('.field label')].find(l => l.textContent.includes('hum/whistle'));
+    if (label) label.scrollIntoView({ block: 'center' });
+    return !!label;
+  `);
+  await gg.sleep(300);
+
+  const drawerState = await gg.evaluate(`
+    const sheet = document.querySelector('.sheet-top');
+    if (!sheet) return { found: false };
+    const rect = sheet.getBoundingClientRect();
+    return { found: true, className: sheet.className, rect: { top: rect.top, left: rect.left, width: rect.width, height: rect.height } };
+  `);
+  console.log('DRAWER_STATE', JSON.stringify(drawerState));
+
+  await gg.screenshot(process.env.GG_SHOT || '/tmp/hum-ui.png');
+
+  const clickResult = await gg.evaluate(`
+    try {
+      const form = document.querySelector('.song-form');
+      const recBtn = form ? [...form.querySelectorAll('.melody-row button')].find(b => b.textContent.includes('Rec')) : null;
+      if (!recBtn) return { clicked: false };
+      recBtn.click();
+      return { clicked: true };
+    } catch (e) {
+      return { clicked: false, error: String(e) };
+    }
+  `);
+  await gg.sleep(800);
+
+  await gg.sleep(1500);   // let a couple seconds of (silent, headless) mic input accumulate
+
+  const stopResult = await gg.evaluate(`
+    const form = document.querySelector('.song-form');
+    const stopBtn = form ? [...form.querySelectorAll('.melody-row button')].find(b => b.textContent.includes('Stop')) : null;
+    if (!stopBtn) return { clicked: false };
+    stopBtn.click();
+    return { clicked: true };
+  `);
+  await gg.sleep(1000);   // decode + pitch-detect is synchronous JS but give the mic stream time to close
+
+  const after = await gg.evaluate(`
+    const errEl = document.querySelector('.hum-error');
+    const capturedEl = document.querySelector('.hum-captured');
+    const buildBtn = document.querySelector('.sb-generate-btn');
+    return {
+      errorText: errEl ? errEl.textContent.trim() : null,
+      capturedText: capturedEl ? capturedEl.textContent.trim() : null,
+      buildBtnText: buildBtn ? buildBtn.textContent.trim() : null,
+    };
+  `);
+  await gg.screenshot((process.env.GG_SHOT || '/tmp/hum-ui.png').replace(/\.png$/, '-after-stop.png'));
+
+  console.log('SCENARIO', JSON.stringify({ switched, opened, before, clickResult, stopResult, after }, null, 2));
+}

backend/app/api/routes_song.py

@@ -31,7 +31,8 @@
                                 RebuildSongProgressionRequest, RearrangeSongSectionsRequest,
                                 AudioClipInfo, PartAutomation,
                                 NoteRegionInfo, SaveNoteRegionRequest, MoveNoteRegionRequest,
-                                SetNoteRegionLoopRequest, NoteRegionMutationResponse)
+                                SetNoteRegionLoopRequest, NoteRegionMutationResponse,
+                                BuildSongFromNotesRequest)
 from app.services.style_loader import load_style
 from app.services.progression_import import parse_progression, ROMAN_TOKEN_RE
 from app.services.midi_writer import (NoteEvent, write_midi, rebuild_combined_from_parts,
@@ -580,6 +581,39 @@ async def build_song_from_melody(
     return _do_build_song(req, user_progression=progression, hook_melody=melody)
 
 
+@router.post("/build-song-from-notes", response_model=BuildSongResponse)
+def build_song_from_notes(req: BuildSongFromNotesRequest):
+    """Build a full song around a hummed/whistled melody (roadmap 8.2).
+
+    The frontend pitch-detects mic audio into a note list client-side (YIN +
+    note segmentation, see frontend/src/utils/pitchDetect.ts) and posts it
+    here as plain note data instead of a MIDI file. From here it's the exact
+    same seam as build-song-from-melody: detect the key, derive a supporting
+    progression, and use the notes as the song's chorus hook.
+    """
+    from app.services.melody_import import detect_key, derive_progression
+
+    melody = [NoteEvent(n.pitch, n.start, n.duration, n.velocity, 2) for n in req.notes]
+    key, scale = detect_key(melody)
+    progression = derive_progression(melody, key, scale)
+
+    try:
+        style = load_style(req.style_id)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    bpm_min, bpm_max = style.get("bpm_range", [40, 240])
+    bpm = int(max(bpm_min, min(bpm_max, req.bpm)))
+
+    build_req = BuildSongRequest(
+        style_id=req.style_id, key=key, scale=scale, bpm=bpm,
+        complexity=req.complexity, variation=req.variation, humanize=req.humanize,
+        parts=req.parts, template=req.template, seed=req.seed, use_priors=req.use_priors,
+        chorus_key_shift=req.chorus_key_shift, final_chorus_lift=req.final_chorus_lift,
+        tempo_automation=req.tempo_automation,
+    )
+    return _do_build_song(build_req, user_progression=progression, hook_melody=melody)
+
+
 def _mine_uploaded_groove(data: bytes) -> dict | None:
     """Mine a finalized groove (derived drum fields + feel + fills) from an
     uploaded drum-MIDI file, reusing the corpus miner (app.mining.drums). Returns

backend/app/models/schemas.py

@@ -186,6 +186,35 @@ class BuildSongRequest(BaseModel):
     progression_text: Optional[str] = Field(default=None, max_length=200)  # free-typed roman numerals or chord names ("Am F C G"); parsed server-side into progression_override
 
 
+class HummedNote(BaseModel):
+    """One note from client-side pitch detection (roadmap 8.2 — see
+    frontend/src/utils/pitchDetect.ts). Units match NoteEvent: beats, not
+    seconds — the frontend quantizes to a grid before posting."""
+    pitch: int = Field(..., ge=0, le=127)
+    start: float = Field(..., ge=0.0)
+    duration: float = Field(..., gt=0.0)
+    velocity: int = Field(default=90, ge=1, le=127)
+
+
+class BuildSongFromNotesRequest(BaseModel):
+    """Build a song around a hummed/whistled melody, pitch-detected client-side
+    (roadmap 8.2). Mirrors build-song-from-melody's fields, minus the MIDI file —
+    a plain note list stands in for it."""
+    notes: List[HummedNote] = Field(..., min_length=4, max_length=256)
+    style_id: str
+    template: str = "verse_chorus"
+    parts: List[str] = ["chords", "bass", "melody", "drums", "pads"]
+    complexity: float = Field(default=0.6, ge=0.0, le=1.0)
+    variation: float = Field(default=0.4, ge=0.0, le=1.0)
+    humanize: float = Field(default=0.5, ge=0.0, le=1.0)
+    use_priors: bool = False
+    chorus_key_shift: Optional[int] = Field(default=None, ge=-12, le=12)
+    final_chorus_lift: Optional[int] = Field(default=None, ge=-12, le=12)
+    tempo_automation: float = Field(default=0.5, ge=0.0, le=1.0)
+    bpm: int = Field(default=100, ge=40, le=240)
+    seed: Optional[int] = None
+
+
 class RegenerateSongPartRequest(BaseModel):
     generation_id: str
     part: str

backend/tests/test_song_features.py

@@ -305,6 +305,68 @@ def test_build_song_from_melody_end_to_end():
     assert fi.part == "drums"
 
 
+# ── Hum/whistle → melody (8.2) ───────────────────────────────────────────────
+
+def _hummed_notes(key_root=60, minor=False) -> list["HummedNote"]:
+    """The same 4-bar diatonic melody as _melody_bytes, as HummedNote objects —
+    stands in for what usePitchDetect.ts would post after pitch-detecting a
+    hummed take."""
+    from app.models.schemas import HummedNote
+    sc = [0, 2, 3, 5, 7, 8, 10] if minor else [0, 2, 4, 5, 7, 9, 11]
+    seqs = [[0, 2, 4, 2], [0, 3, 5, 3], [4, 2, 1, 0], [0, 1, 2, 0]]
+    notes = []
+    for bar, steps in enumerate(seqs):
+        for q, s in enumerate(steps):
+            notes.append(HummedNote(pitch=key_root + sc[s], start=bar * 4 + q, duration=0.9, velocity=90))
+    return notes
+
+
+def test_build_song_from_notes_end_to_end():
+    """A hummed note list (no MIDI file involved) reaches the same seam as
+    build-song-from-melody: key detection, progression derivation, and the
+    notes become the chorus hook."""
+    from app.models.schemas import BuildSongFromNotesRequest
+    from app.api.routes_song import build_song_from_notes
+
+    notes = _hummed_notes()
+    r = build_song_from_notes(BuildSongFromNotesRequest(
+        notes=notes, style_id="lofi", template="compact",
+        parts=["chords", "bass", "melody", "drums"], complexity=0.6, variation=0.4,
+        humanize=0.5, use_priors=False, chorus_key_shift=0, final_chorus_lift=0,
+        tempo_automation=0.5, bpm=100, seed=64))
+    assert r.key.startswith("C major")
+    d = EXPORTS_DIR / r.generation_id
+
+    chorus = next(s for s in r.sections if s.section_type == "chorus")
+    mid = mido.MidiFile(str(d / "melody.mid"))
+    tpb = mid.ticks_per_beat
+    mid_notes = []
+    for tr in mid.tracks:
+        t = 0
+        for msg in tr:
+            t += msg.time
+            if msg.type == "note_on" and msg.velocity > 0:
+                mid_notes.append((t / tpb, msg.note))
+    lo, hi = chorus.start_bar * 4, (chorus.start_bar + chorus.bars) * 4
+    chorus_notes = {(round((t - lo) % 16, 1), p) for t, p in mid_notes if lo <= t < hi}
+    hook_set = {(round(n.start, 1), n.pitch) for n in notes}
+    matched = sum(1 for ev in hook_set if ev in chorus_notes)
+    assert matched / len(hook_set) >= 0.9, "chorus should carry the hummed hook"
+
+
+def test_build_song_from_notes_clamps_bpm_to_style_range():
+    from app.models.schemas import BuildSongFromNotesRequest
+    from app.api.routes_song import build_song_from_notes
+
+    r = build_song_from_notes(BuildSongFromNotesRequest(
+        notes=_hummed_notes(), style_id="lofi", template="compact",
+        parts=["chords", "bass", "melody", "drums"], use_priors=False,
+        bpm=240, seed=65))   # above lofi's bpm_range (70-90)
+    from app.services.style_loader import load_style
+    bpm_min, bpm_max = load_style("lofi").get("bpm_range", [40, 240])
+    assert bpm_min <= r.bpm <= bpm_max
+
+
 # ── Seed from a progression (5.4a) ───────────────────────────────────────────
 
 def test_build_song_with_progression_text_pins_harmony():

frontend/package-lock.json

@@ -1,7 +1,7 @@
 {
   "name": "genregrid-frontend",
   "private": true,
-  "version": "0.12.0",
+  "version": "0.13.0",
   "desktopName": "genregrid.desktop",
   "license": "GPL-3.0-or-later",
   "description": "Genregrid — A Midi Loop Generator",