Add chord detection, stems, and reaper modules

- Add modules/chords.py with real chord detection using librosa
- Add modules/stems.py for Demucs stem separation
- Add modules/reaper.py for Reaper project generation
- Update app.py to use real chord detection instead of placeholder
- Lower chord confidence threshold from 0.25 to 0.12 for better detection

app.py

@@ -61,6 +61,14 @@ except ImportError:
     HAS_CATALOG = False
     print("Catalog module not available")
 
+# Chord detection module
+try:
+    from modules.chords import extract_chords
+    HAS_CHORD_DETECTION = True
+except ImportError:
+    HAS_CHORD_DETECTION = False
+    print("Chord detection module not available")
+
 # AI Generator (optional)
 HAS_AUDIOCRAFT = False
 try:
@@ -390,10 +398,30 @@ def process_song(audio, yt_url, name, lyrics, do_stems, do_chords, do_daw, user_
 
     # Chords
     chords_text = None
+    chords_list = []
     if do_chords:
         progress(0.7, "Detecting chords...")
-        chords_text = f"# {song_name}\nKey: {analysis.get('key', 'C')}\nBPM: {analysis.get('bpm', 120)}\n\n[Chord detection - implement with chord-extractor]"
-        log.append("Chord chart generated")
+        if HAS_CHORD_DETECTION:
+            try:
+                chords_list = extract_chords(audio_path, min_duration=1.0)
+                if chords_list:
+                    # Format as chord chart
+                    lines = [f"# {song_name}", f"Key: {analysis.get('key', 'C')} | BPM: {analysis.get('bpm', 120)}", ""]
+                    for time, chord in chords_list:
+                        mins = int(time // 60)
+                        secs = time % 60
+                        lines.append(f"[{mins}:{secs:05.2f}] {chord}")
+                    chords_text = "\n".join(lines)
+                    log.append(f"Chord chart: {len(chords_list)} changes detected")
+                else:
+                    chords_text = f"# {song_name}\nKey: {analysis.get('key', 'C')}\nBPM: {analysis.get('bpm', 120)}\n\n(No chord changes detected)"
+                    log.append("Chord detection: no changes found")
+            except Exception as e:
+                chords_text = f"# {song_name}\nChord detection error: {str(e)}"
+                log.append(f"Chord detection error: {e}")
+        else:
+            chords_text = f"# {song_name}\nKey: {analysis.get('key', 'C')}\nBPM: {analysis.get('bpm', 120)}\n\n(Chord detection not available)"
+            log.append("Chord detection not available")
 
     # Save to catalog
     if HAS_CATALOG:

modules/__init__.py

@@ -0,0 +1,4 @@
+# VYNL Modules
+from .chords import extract_chords, extract_chords_multi_stem
+from .stems import separate_stems as separate_stems_demucs, list_stems
+from .reaper import create_reaper_project

modules/chords.py

@@ -0,0 +1,298 @@
+"""
+Multi-Source Chord Detection
+Analyzes stems AND full mix for best results
+"""
+
+import numpy as np
+import warnings
+warnings.filterwarnings('ignore')
+
+try:
+    import librosa
+    import scipy.ndimage
+    LIBROSA_AVAILABLE = True
+except ImportError:
+    LIBROSA_AVAILABLE = False
+
+
+def extract_chords_multi_stem(stems_dir, original_audio=None, min_duration=0.5):
+    """
+    Extract chords from multiple sources - stems AND full track
+    
+    Args:
+        stems_dir: Path to directory containing stems
+        original_audio: Path to original full mix (optional but recommended)
+        min_duration: Minimum chord duration
+    
+    Returns:
+        List of (timestamp, chord_name) tuples
+    """
+    
+    if not LIBROSA_AVAILABLE:
+        print("   [WARN]  Chord extraction skipped (librosa not installed)")
+        return []
+    
+    from pathlib import Path
+    stems_dir = Path(stems_dir)
+    
+    print(f"   Analyzing multiple sources for chord detection...")
+    
+    chord_candidates = []
+    
+    # SOURCE 1: Original full mix (HIGHEST WEIGHT)
+    if original_audio and Path(original_audio).exists():
+        print(f"   • Full mix (original audio)")
+        full_chords = detect_chords_from_stem(original_audio, focus='harmony')
+        if full_chords:
+            chord_candidates.append(('full_mix', full_chords, 4.0))
+    
+    # SOURCE 2: Bass stem
+    for stem_file in stems_dir.glob('*.mp3'):
+        if 'bass' in stem_file.stem.lower():
+            print(f"   • Bass stem")
+            bass_chords = detect_chords_from_stem(stem_file, focus='bass')
+            if bass_chords:
+                chord_candidates.append(('bass', bass_chords, 3.0))
+            break
+    
+    # SOURCE 3: Guitar stem
+    for stem_file in stems_dir.glob('*.mp3'):
+        if 'guitar' in stem_file.stem.lower():
+            print(f"   • Guitar stem")
+            guitar_chords = detect_chords_from_stem(stem_file, focus='harmony')
+            if guitar_chords:
+                chord_candidates.append(('guitar', guitar_chords, 2.5))
+            break
+    
+    # SOURCE 4: Piano/Keys
+    for stem_file in stems_dir.glob('*.mp3'):
+        name_lower = stem_file.stem.lower()
+        if 'piano' in name_lower or 'keys' in name_lower:
+            print(f"   • Piano/Keys stem")
+            piano_chords = detect_chords_from_stem(stem_file, focus='harmony')
+            if piano_chords:
+                chord_candidates.append(('piano', piano_chords, 2.0))
+            break
+    
+    # SOURCE 5: Other stem
+    for stem_file in stems_dir.glob('*.mp3'):
+        if 'other' in stem_file.stem.lower():
+            print(f"   • Other stem")
+            other_chords = detect_chords_from_stem(stem_file, focus='harmony')
+            if other_chords:
+                chord_candidates.append(('other', other_chords, 1.5))
+            break
+    
+    if not chord_candidates:
+        print("   [WARN]  No suitable sources found")
+        return []
+    
+    print(f"   Merging results from {len(chord_candidates)} sources...")
+    merged_chords = merge_chord_detections(chord_candidates, min_duration)
+    
+    return merged_chords
+
+
+def detect_chords_from_stem(stem_file, focus='harmony'):
+    """Detect chords - FULL SONG"""
+    
+    try:
+        y, sr = librosa.load(str(stem_file), sr=22050, duration=None)
+        hop_length = 256 if focus == 'bass' else 512
+        chroma = librosa.feature.chroma_cqt(y=y, sr=sr, hop_length=hop_length)
+        chroma = scipy.ndimage.median_filter(chroma, size=(1, 9))
+        
+        templates = create_chord_templates()
+        chords = []
+        last_chord = None
+        
+        for i in range(chroma.shape[1]):
+            frame = chroma[:, i]
+            time = librosa.frames_to_time(i, sr=sr, hop_length=hop_length)
+            chord, confidence = match_chord_template_with_confidence(frame, templates, focus)
+            
+            if chord != last_chord and confidence > 0.12:
+                chords.append((float(time), chord, float(confidence)))
+                last_chord = chord
+        
+        return chords
+        
+    except Exception as e:
+        from pathlib import Path
+        print(f"   [WARN]  Failed to analyze {Path(stem_file).name}: {e}")
+        return []
+
+
+def merge_chord_detections(chord_candidates, min_duration=0.5):
+    """Merge - if only one source, just use it directly"""
+    
+    # If only one source, don't filter - just use it
+    if len(chord_candidates) == 1:
+        name, chords, weight = chord_candidates[0]
+        # Convert (time, chord, conf) to (time, chord)
+        return [(time, chord) for time, chord, conf in chords]
+    
+    # Multiple sources - merge
+    all_times = set()
+    for name, chords, weight in chord_candidates:
+        for time, chord, conf in chords:
+            all_times.add(time)
+    
+    all_times = sorted(all_times)
+    
+    if not all_times:
+        return []
+    
+    time_grid = np.arange(0, max(all_times) + 1, 0.5)
+    
+    merged = []
+    last_chord = None
+    last_time = 0
+    
+    for grid_time in time_grid:
+        votes = {}
+        total_weight = 0
+        
+        for name, chords, weight in chord_candidates:
+            active_chord = get_chord_at_time(chords, grid_time)
+            
+            if active_chord:
+                chord, conf = active_chord
+                vote_strength = conf * weight
+                
+                if chord in votes:
+                    votes[chord] += vote_strength
+                else:
+                    votes[chord] = vote_strength
+                
+                total_weight += weight
+        
+        if votes:
+            best_chord = max(votes.items(), key=lambda x: x[1])[0]
+            
+            # Less strict threshold
+            if best_chord != last_chord:
+                if last_chord is not None:
+                    duration = grid_time - last_time
+                    if duration >= min_duration:
+                        merged.append((last_time, last_chord))
+                
+                last_chord = best_chord
+                last_time = grid_time
+    
+    if last_chord:
+        merged.append((last_time, last_chord))
+    
+    return merged
+
+
+def get_chord_at_time(chords, time):
+    """Find active chord"""
+    active_chord = None
+    for chord_time, chord, conf in chords:
+        if chord_time <= time:
+            active_chord = (chord, conf)
+        else:
+            break
+    return active_chord
+
+
+def create_chord_templates():
+    """Enhanced chord templates"""
+    notes = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
+    templates = {}
+    
+    for i, root in enumerate(notes):
+        # Major
+        template = np.zeros(12)
+        template[(i + 0) % 12] = 1.0
+        template[(i + 4) % 12] = 0.8
+        template[(i + 7) % 12] = 0.6
+        templates[root] = template
+        
+        # Minor
+        template = np.zeros(12)
+        template[(i + 0) % 12] = 1.0
+        template[(i + 3) % 12] = 0.8
+        template[(i + 7) % 12] = 0.6
+        templates[root + 'm'] = template
+        
+        # Dominant 7
+        template = np.zeros(12)
+        template[(i + 0) % 12] = 1.0
+        template[(i + 4) % 12] = 0.7
+        template[(i + 7) % 12] = 0.5
+        template[(i + 10) % 12] = 0.4
+        templates[root + '7'] = template
+        
+        # Major 7
+        template = np.zeros(12)
+        template[(i + 0) % 12] = 1.0
+        template[(i + 4) % 12] = 0.7
+        template[(i + 7) % 12] = 0.5
+        template[(i + 11) % 12] = 0.4
+        templates[root + 'maj7'] = template
+        
+        # Minor 7
+        template = np.zeros(12)
+        template[(i + 0) % 12] = 1.0
+        template[(i + 3) % 12] = 0.7
+        template[(i + 7) % 12] = 0.5
+        template[(i + 10) % 12] = 0.4
+        templates[root + 'm7'] = template
+    
+    return templates
+
+
+def match_chord_template_with_confidence(chroma_frame, templates, focus='harmony'):
+    """Match with confidence"""
+    if chroma_frame.sum() > 0:
+        chroma_frame = chroma_frame / chroma_frame.sum()
+    
+    best_chord = 'C'
+    best_score = -1
+    
+    for chord_name, template in templates.items():
+        if template.sum() > 0:
+            template_norm = template / template.sum()
+        else:
+            continue
+        
+        score = np.dot(chroma_frame, template_norm)
+        
+        if focus == 'bass' and not ('7' in chord_name or 'm' in chord_name):
+            score *= 1.1
+        
+        if score > best_score:
+            best_score = score
+            best_chord = chord_name
+    
+    return best_chord, best_score
+
+
+def extract_chords(audio_path, min_duration=0.5):
+    """Fallback single-file"""
+    if not LIBROSA_AVAILABLE:
+        return []
+    
+    try:
+        y, sr = librosa.load(audio_path, sr=22050, duration=None)
+        chroma = librosa.feature.chroma_cqt(y=y, sr=sr, hop_length=512)
+        chroma = scipy.ndimage.median_filter(chroma, size=(1, 9))
+        
+        templates = create_chord_templates()
+        chords = []
+        last_chord = None
+        
+        for i in range(chroma.shape[1]):
+            frame = chroma[:, i]
+            time = librosa.frames_to_time(i, sr=sr, hop_length=512)
+            chord, conf = match_chord_template_with_confidence(frame, templates, 'harmony')
+            
+            if chord != last_chord and conf > 0.12:
+                chords.append((float(time), chord))
+                last_chord = chord
+        
+        return chords
+    except:
+        return []

modules/reaper.py

@@ -0,0 +1,465 @@
+"""
+Ultimate Reaper Project Generator
+- Precise tempo map with fluctuations
+- Chord change markers throughout track
+- Region-based song structure
+- Lyric file integration for better structure detection
+- Color-coded markers and regions
+"""
+
+from pathlib import Path
+import numpy as np
+import re
+
+try:
+    import librosa
+    LIBROSA_AVAILABLE = True
+except ImportError:
+    LIBROSA_AVAILABLE = False
+
+
+# Color scheme for Reaper (BGR format as integers)
+COLORS = {
+    # Regions
+    'intro': 8421504,      # Gray
+    'verse': 16744703,     # Light blue
+    'pre-chorus': 16777011, # Light yellow
+    'chorus': 8454143,     # Green
+    'bridge': 16744576,    # Orange
+    'solo': 16711935,      # Purple
+    'outro': 8421504,      # Gray
+    'fill': 12632256,      # Light gray
+    
+    # Chords - by function
+    'tonic': 8454143,      # Green (I, i)
+    'subdominant': 16776960, # Yellow (IV, iv)
+    'dominant': 33488896,  # Red (V, V7)
+    'default': 16777215,   # White
+}
+
+
+def create_reaper_project(song_name, stems_dir, tempo, key, structure=None, 
+                         chords=None, lyrics_file=None, audio_file=None):
+    """
+    Generate ultimate Reaper project with full integration
+    
+    Args:
+        song_name: Name of the song
+        stems_dir: Directory containing stem files
+        tempo: Average tempo in BPM
+        key: Musical key
+        structure: Detected song structure
+        chords: List of (timestamp, chord_name) tuples
+        lyrics_file: Optional path to lyric file with structure tags
+        audio_file: Original audio file for beat detection
+    
+    Returns:
+        RPP file content as string
+    """
+    
+    stems_dir = Path(stems_dir)
+    stem_files = sorted(stems_dir.glob('*.mp3'))
+    
+    if not stem_files:
+        return create_empty_project(song_name, tempo)
+    
+    # Parse lyric file if provided
+    lyric_structure = None
+    if lyrics_file and Path(lyrics_file).exists():
+        print("   Parsing lyric file for structure...")
+        lyric_structure = parse_lyric_file(lyrics_file)
+    
+    # Merge detected structure with lyric structure
+    if lyric_structure:
+        structure = merge_structures(structure, lyric_structure)
+    
+    # Detect precise beats and tempo map
+    print("   Detecting precise beat grid and tempo map...")
+    audio_to_analyze = audio_file if audio_file else stem_files[0]
+    beats, downbeats, tempo_map = detect_precise_beats(audio_to_analyze)
+    
+    # Start building RPP
+    rpp_lines = []
+    
+    # === HEADER ===
+    rpp_lines.append('<REAPER_PROJECT 0.1 "6.0/linux-x86_64" 1234567890')
+    rpp_lines.append('  RIPPLE 0')
+    rpp_lines.append('  GROUPOVERRIDE 0 0 0')
+    rpp_lines.append('  AUTOXFADE 1')
+    
+    # === TEMPO MAP ===
+    if tempo_map and len(tempo_map) > 1:
+        # Variable tempo - use multiple TEMPO markers (Reaper 6.x format)
+        print(f"   Creating tempo map with {len(tempo_map)} changes...")
+        
+        # First tempo at project start
+        rpp_lines.append(f'  TEMPO {tempo_map[0]["bpm"]:.6f} 4 4')
+        
+        # Add tempo changes as additional TEMPO lines with time position
+        # Format: TEMPO bpm timesig beat_position
+        for i, tm in enumerate(tempo_map[1:], 1):
+            # Calculate beat position from time
+            beat_pos = tm["time"] * tempo_map[0]["bpm"] / 60.0
+            rpp_lines.append(f'  TEMPO {tm["bpm"]:.6f} 4 4 {beat_pos:.6f}')
+    else:
+        # Constant tempo
+        rpp_lines.append(f'  TEMPO {tempo:.6f} 4 4')
+    
+    rpp_lines.append('  PLAYRATE 1 0 0.25 4')
+    rpp_lines.append('  CURSOR 0')
+    rpp_lines.append('  ZOOM 100 0 0')
+    rpp_lines.append('  VZOOMEX 1 0')
+    rpp_lines.append('  USE_REC_CFG 0')
+    rpp_lines.append('  RECMODE 1')
+    rpp_lines.append('  SMPTESYNC 0 30 100 40 1000 300 0 0 1 0 0')
+    rpp_lines.append('  LOOP 0')
+    rpp_lines.append('  LOOPGRAN 0 4')
+    rpp_lines.append('  RECORD_PATH "" ""')
+    rpp_lines.append('')
+    
+    # === DOWNBEAT MARKERS (BAR LINES) ===
+    if downbeats is not None and len(downbeats) > 0:
+        print(f"   Creating {len(downbeats)} bar markers...")
+        for i, beat_time in enumerate(downbeats):
+            bar_number = i + 1
+            adjusted_time = beat_time + 8.0  # Offset by pre-roll
+            rpp_lines.append(f'  MARKER {bar_number} {adjusted_time:.6f} "Bar {bar_number}" 0 0')
+    
+    # === CHORD MARKERS ===
+    marker_id = len(downbeats) + 1 if downbeats is not None else 1
+    
+    if chords and len(chords) > 0:
+        print(f"   Creating {len(chords)} chord change markers...")
+        for time, chord in chords:
+            color = get_chord_color(chord, key)
+            adjusted_time = time + 8.0  # Offset by pre-roll
+            rpp_lines.append(f'  MARKER {marker_id} {adjusted_time:.6f} "{chord}" 0 {color}')
+            marker_id += 1
+    
+    rpp_lines.append('')
+    
+    # === REGIONS (SONG STRUCTURE) ===
+    
+    # Add count-in region at start
+    print("   Creating count-in region (8 seconds)...")
+    rpp_lines.append(f'  MARKER {marker_id} 0.0 "Count-In" 1 {COLORS["intro"]} {{}} 0')
+    marker_id += 1
+    rpp_lines.append(f'  MARKER {marker_id} 8.0 "" 1 {COLORS["intro"]} {{}} 0')
+    marker_id += 1
+    
+    if structure and len(structure) > 0:
+        print(f"   Creating {len(structure)} structural regions...")
+        region_id = 1
+        for section in structure:
+            section_name = section['name']
+            start = section['start'] + 8.0  # Offset by pre-roll
+            end = section['end'] + 8.0
+            color = get_section_color(section_name)
+            
+            # Regions use different format: MARKER with region flag
+            rpp_lines.append(
+                f'  MARKER {marker_id} {start:.6f} "{section_name}" 1 {color} {{}} {region_id}'
+            )
+            marker_id += 1
+            
+            # Region end
+            rpp_lines.append(
+                f'  MARKER {marker_id} {end:.6f} "" 1 {color} {{}} {region_id}'
+            )
+            marker_id += 1
+            region_id += 1
+    
+    rpp_lines.append('')
+    
+    # === TRACKS ===
+    track_number = 1
+    
+    for stem_file in stem_files:
+        stem_name = stem_file.stem.replace('_', ' ').title()
+        color = get_track_color(stem_name)
+        
+        rpp_lines.append('  <TRACK')
+        rpp_lines.append(f'    NAME "{stem_name}"')
+        rpp_lines.append(f'    PEAKCOL {color}')
+        rpp_lines.append('    BEAT -1')
+        rpp_lines.append('    AUTOMODE 0')
+        rpp_lines.append('    VOLPAN 1 0 -1 -1 1')
+        rpp_lines.append('    MUTESOLO 0 0 0')
+        rpp_lines.append('    IPHASE 0')
+        rpp_lines.append('    PLAYOFFS 0 1')
+        rpp_lines.append('    ISBUS 0 0')
+        rpp_lines.append('    BUSCOMP 0 0 0 0 0')
+        rpp_lines.append('    SHOWINMIX 1 0.6667 0.5 1 0.5 0 0 0')
+        rpp_lines.append('    FREEMODE 0')
+        rpp_lines.append('    SEL 0')
+        rpp_lines.append('    REC 0 0 1 0 0 0 0')
+        rpp_lines.append('    VU 2')
+        rpp_lines.append('    TRACKHEIGHT 0 0 0 0 0 0')
+        rpp_lines.append('    INQ 0 0 0 0.5 100 0 0 100')
+        rpp_lines.append('    NCHAN 2')
+        rpp_lines.append('    FX 1')
+        rpp_lines.append('    TRACKID')
+        rpp_lines.append('    PERF 0')
+        rpp_lines.append('    MIDIOUT -1')
+        rpp_lines.append('    MAINSEND 1 0')
+        
+        # Item (audio)
+        rpp_lines.append('    <ITEM')
+        rpp_lines.append('      POSITION 8.0')  # 8-second pre-roll
+        rpp_lines.append('      SNAPOFFS 0')
+        rpp_lines.append('      LENGTH 0')
+        rpp_lines.append('      LOOP 0')
+        rpp_lines.append('      ALLTAKES 0')
+        rpp_lines.append('      FADEIN 1 0.01 0 1 0 0 0')
+        rpp_lines.append('      FADEOUT 1 0.01 0 1 0 0 0')
+        rpp_lines.append('      MUTE 0 0')
+        rpp_lines.append('      SEL 1')
+        rpp_lines.append('      IGUID')
+        rpp_lines.append(f'      IID {track_number}')
+        rpp_lines.append(f'      NAME "{stem_name}"')
+        rpp_lines.append('      VOLPAN 1 0 1 -1')
+        rpp_lines.append('      SOFFS 0 0')
+        rpp_lines.append('      PLAYRATE 1 1 0 -1 0 0.0025')
+        rpp_lines.append('      CHANMODE 0')
+        rpp_lines.append('      GUID')
+        rpp_lines.append('      RESOURCECH 0')
+        rpp_lines.append('      <SOURCE WAVE')
+        rpp_lines.append(f'        FILE "{stem_file.absolute()}"')
+        rpp_lines.append('      >')
+        rpp_lines.append('    >')
+        rpp_lines.append('  >')
+        rpp_lines.append('')
+        
+        track_number += 1
+    
+    # Footer
+    rpp_lines.append('>')
+    
+    return '\n'.join(rpp_lines)
+
+
+def parse_lyric_file(lyrics_path):
+    """
+    Parse lyric file with structure tags
+    
+    Expected format:
+        [Intro]
+        
+        [Verse 1]
+        Lyrics here...
+        
+        [Chorus]
+        Lyrics here...
+    
+    Returns:
+        List of {'name': str, 'lyrics': str} dicts
+    """
+    
+    with open(lyrics_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+    
+    # Pattern: [Section Name]
+    sections = []
+    current_section = None
+    current_lyrics = []
+    
+    for line in content.split('\n'):
+        # Check for section tag
+        match = re.match(r'\[(.*?)\]', line.strip())
+        if match:
+            # Save previous section
+            if current_section:
+                sections.append({
+                    'name': current_section,
+                    'lyrics': '\n'.join(current_lyrics).strip()
+                })
+            
+            # Start new section
+            current_section = match.group(1)
+            current_lyrics = []
+        else:
+            # Add to current section
+            if current_section:
+                current_lyrics.append(line)
+    
+    # Save last section
+    if current_section:
+        sections.append({
+            'name': current_section,
+            'lyrics': '\n'.join(current_lyrics).strip()
+        })
+    
+    return sections
+
+
+def merge_structures(detected_structure, lyric_structure):
+    """
+    Merge detected structure with lyric file structure
+    Lyric file takes precedence for naming
+    """
+    
+    if not detected_structure:
+        return lyric_structure
+    
+    if not lyric_structure:
+        return detected_structure
+    
+    # Use detected timestamps but lyric names
+    merged = []
+    
+    for i, detected in enumerate(detected_structure):
+        if i < len(lyric_structure):
+            # Use lyric name but detected times
+            merged.append({
+                'name': lyric_structure[i]['name'],
+                'start': detected['start'],
+                'end': detected['end'],
+                'lyrics': lyric_structure[i].get('lyrics', '')
+            })
+        else:
+            merged.append(detected)
+    
+    return merged
+
+
+def detect_precise_beats(audio_file):
+    """
+    Detect beats, downbeats, and tempo map with high precision
+    
+    Returns:
+        (beats, downbeats, tempo_map)
+    """
+    
+    if not LIBROSA_AVAILABLE:
+        return None, None, None
+    
+    try:
+        # Load audio
+        y, sr = librosa.load(str(audio_file), sr=22050)
+        duration = len(y) / sr
+        
+        # Detect all beats
+        tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr, units='frames')
+        beat_times = librosa.frames_to_time(beat_frames, sr=sr)
+        
+        # Estimate downbeats (every 4 beats assuming 4/4)
+        downbeat_times = beat_times[::4]
+        
+        # Create detailed tempo map (every 2 seconds)
+        tempo_map = []
+        window_size = 2.0  # seconds
+        
+        for start_time in np.arange(0, duration, window_size):
+            end_time = min(start_time + window_size, duration)
+            start_sample = int(start_time * sr)
+            end_sample = int(end_time * sr)
+            
+            if end_sample > start_sample:
+                segment = y[start_sample:end_sample]
+                try:
+                    segment_tempo, _ = librosa.beat.beat_track(y=segment, sr=sr)
+                    tempo_map.append({
+                        'time': float(start_time),
+                        'bpm': float(segment_tempo)
+                    })
+                except:
+                    # Use global tempo if segment fails
+                    tempo_map.append({
+                        'time': float(start_time),
+                        'bpm': float(tempo)
+                    })
+        
+        # Smooth tempo map to reduce noise
+        tempo_map = smooth_tempo_map(tempo_map)
+        
+        # Check if tempo is stable enough to treat as constant
+        tempos = [tm['bpm'] for tm in tempo_map]
+        tempo_std = np.std(tempos)
+        
+        if tempo_std < 3:  # Less than 3 BPM variation
+            tempo_map = [tempo_map[0]]  # Use constant tempo
+        
+        return beat_times, downbeat_times, tempo_map
+        
+    except Exception as e:
+        print(f"   [WARN]  Beat detection failed: {e}")
+        return None, None, None
+
+
+def smooth_tempo_map(tempo_map, window=3):
+    """Smooth tempo map with moving average"""
+    
+    if len(tempo_map) <= window:
+        return tempo_map
+    
+    smoothed = []
+    for i, tm in enumerate(tempo_map):
+        start = max(0, i - window // 2)
+        end = min(len(tempo_map), i + window // 2 + 1)
+        
+        avg_tempo = np.mean([tempo_map[j]['bpm'] for j in range(start, end)])
+        
+        smoothed.append({
+            'time': tm['time'],
+            'bpm': float(avg_tempo)
+        })
+    
+    return smoothed
+
+
+def get_chord_color(chord, key):
+    """Get color for chord based on function in key"""
+    
+    # Simplified: just use default white for now
+    # Could be enhanced to detect I, IV, V based on key
+    return COLORS['default']
+
+
+def get_section_color(section_name):
+    """Get color for section type"""
+    
+    name_lower = section_name.lower()
+    
+    for section_type, color in COLORS.items():
+        if section_type in name_lower:
+            return color
+    
+    return COLORS['intro']  # Default
+
+
+def get_track_color(track_name):
+    """Get color for track based on instrument"""
+    
+    name_lower = track_name.lower()
+    
+    if 'vocal' in name_lower or 'voice' in name_lower:
+        return 16576  # Blue
+    elif 'drum' in name_lower:
+        return 33488896  # Red
+    elif 'bass' in name_lower:
+        return 25387775  # Purple
+    elif 'guitar' in name_lower:
+        return 8454143  # Green
+    elif 'piano' in name_lower or 'key' in name_lower:
+        return 16776960  # Yellow
+    else:
+        return 8421504  # Gray
+
+
+def create_empty_project(song_name, tempo):
+    """Create minimal project if no stems found"""
+    
+    return f"""<REAPER_PROJECT 0.1 "6.0/linux-x86_64" 1234567890
+  TEMPO {tempo} 4 4
+>
+"""
+
+
+if __name__ == "__main__":
+    print("Reaper Ultimate Integration Module")
+    print("Features:")
+    print("  • Precise tempo map with fluctuation detection")
+    print("  • Chord change markers throughout track")
+    print("  • Region-based song structure")
+    print("  • Lyric file integration")
+    print("  • Color-coded everything")

modules/stems.py

@@ -0,0 +1,132 @@
+"""
+Stem Separation Module
+Uses Demucs for audio source separation
+"""
+
+import subprocess
+from pathlib import Path
+import sys
+
+
+def separate_stems(input_file, output_dir, two_stem=True):
+    """
+    Separate audio into stems using Demucs (CPU mode)
+    
+    Args:
+        input_file: Path to input audio file
+        output_dir: Directory to save stems
+        two_stem: If True, only separate vocals/instrumental (faster)
+                  If False, separate into 6 stems (slower)
+    
+    Returns:
+        Path to directory containing stems
+    """
+    
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+    
+    if two_stem:
+        print(f"   Using 2-stem mode (vocal + instrumental)")
+        print(f"   Estimated time: 2-4 minutes")
+        
+        cmd = [
+            'demucs',
+            '--two-stems=vocals',
+            '-o', str(output_path),
+            '--mp3',
+            '--mp3-bitrate=320',
+            '--jobs=0',  # Use all CPU cores
+            input_file
+        ]
+    else:
+        print(f"   Using 6-stem mode (vocal, drums, bass, guitar, keys, other)")
+        print(f"   Estimated time: 8-12 minutes")
+        
+        cmd = [
+            'demucs',
+            '-n', 'htdemucs_6s',
+            '-o', str(output_path),
+            '--mp3',
+            '--mp3-bitrate=320',
+            '--jobs=0',
+            input_file
+        ]
+    
+    try:
+        # Run Demucs with live output
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+            bufsize=1
+        )
+        
+        # Print progress
+        for line in process.stdout:
+            line = line.strip()
+            if line:
+                # Filter for progress info
+                if '%' in line or 'Separated' in line or 'Processing' in line:
+                    print(f"   {line}")
+        
+        process.wait()
+        
+        if process.returncode != 0:
+            raise Exception(f"Demucs exited with code {process.returncode}")
+        
+        # Locate output directory
+        # Demucs structure: output_dir/model_name/track_name/stems
+        song_stem = Path(input_file).stem
+        
+        # Try different possible structures
+        possible_paths = [
+            output_path / 'htdemucs' / song_stem,
+            output_path / 'htdemucs_6s' / song_stem,
+            output_path / song_stem
+        ]
+        
+        for stems_dir in possible_paths:
+            if stems_dir.exists():
+                # Verify stems are present
+                stem_files = list(stems_dir.glob('*.mp3'))
+                if stem_files:
+                    return stems_dir
+        
+        # If we get here, something went wrong
+        raise Exception(f"Could not find output stems in {output_path}")
+        
+    except FileNotFoundError:
+        print("\n[FAIL] Error: 'demucs' command not found")
+        print("   Make sure Demucs is installed:")
+        print("   pip install demucs")
+        sys.exit(1)
+        
+    except Exception as e:
+        raise Exception(f"Stem separation failed: {str(e)}")
+
+
+def list_stems(stems_dir):
+    """List all stem files in directory"""
+    stems_dir = Path(stems_dir)
+    return sorted(stems_dir.glob('*.mp3'))
+
+
+if __name__ == "__main__":
+    # Test module
+    import sys
+    
+    if len(sys.argv) < 2:
+        print("Usage: python stems.py <audio_file>")
+        sys.exit(1)
+    
+    test_file = sys.argv[1]
+    test_output = "./test_output"
+    
+    print(f"Testing stem separation on: {test_file}")
+    result = separate_stems(test_file, test_output, two_stem=True)
+    
+    print(f"\nStems created in: {result}")
+    print("\nFiles:")
+    for stem in list_stems(result):
+        print(f"  • {stem.name}")