midi-cli 0.1.3__tar.gz → 0.2.0__tar.gz

{midi_cli-0.1.3 → midi_cli-0.2.0}/.gitignore

@@ -8,3 +8,4 @@ build/
 samples/
 samples-*/
 config.json
+.claude/settings.local.json

midi_cli-0.2.0/ARCHITECTURE.md

@@ -0,0 +1,144 @@
+# Architecture
+
+Developer reference for midi-cli: modes, key behavior, and app flow.
+
+## Module Overview
+
+| File | Responsibility |
+|------|---------------|
+| `app.py` | Entry point, main loop, raw key input, mode switching |
+| `state.py` | All global state and constants (single source of truth) |
+| `audio.py` | `sd.OutputStream` callback; synth rendering, sample playback, loop mixing, metronome |
+| `midi.py` | MIDI input callback; keyboard mock input (`trigger_keyboard_note`) |
+| `sampler.py` | Sample I/O (load/save WAV), pitch shifting, chromatic pre-computation, split/copy |
+| `loop.py` | Loop state machine transitions (`cycle_loop_state`) |
+| `ui.py` | Terminal rendering (`draw_ui`); trim/copy/split state resets |
+| `config.py` | Config file load/save, device enumeration |
+
+## Startup Flow
+
+1. `load_defaults()` reads saved config (devices, MIDI port, synesthesia)
+2. MIDI input opened; if unavailable, falls back to keyboard mock mode
+3. `load_samples()` reads `samples/note_*.wav` into `state.samples`
+4. `load_pitch_offsets()` reads `samples/pitch_offsets.json`
+5. `sd.OutputStream` started (runs `audio_callback` on a background thread)
+6. Terminal set to raw mode, alternate screen entered
+7. Main loop: `draw_ui()` → `select()` with 50ms timeout → handle key
+
+## Modes
+
+Modes are stored in `state.mode`. The ordered list is defined in `state.MODES`:
+
+```
+synth → sample → record → pitch → chromatic → trim → copy → loop → split → config
+```
+
+- **Tab** advances to the next mode (wraps)
+- **Shift+Tab** goes to the previous mode
+- Switching away from `record`, `trim`, `copy`, `split`, or `loop` resets that mode's transient state
+
+### synth
+Polyphonic additive synth (5 harmonics, piano-like two-stage decay).  
+Note on → voice added to `state.voices`. Note off → voice set to `releasing`.  
+Sustain pedal (CC 64) holds notes until pedal release.
+
+### sample
+Plays back recorded samples. Note on → sample voice added to `state.sample_voices`, plays from position 0.  
+Note off → voice set to `releasing` (5ms fade out). Sample plays to its natural end before being removed.
+
+### record
+Note on → `start_recording()` (opens `sd.InputStream`, accumulates chunks).  
+Note off → `stop_recording()` (closes stream, trims silence, saves WAV).  
+In keyboard mock mode: key press **toggles** recording on/off (press once to start, again to stop).
+
+### pitch
+Note on → plays the sample and sets `pitch_selected_note`.  
+Arrow keys adjust pitch offset for the selected note (Up/Down: ±1 semitone, Left/Right: ±10 cents).  
+Changes saved to `samples/pitch_offsets.json` and recomputed asynchronously via pyrubberband.
+
+### chromatic
+One sample is pitch-shifted across a two-octave range (±12 semitones from root) and pre-computed in a background thread into `state.chromatic_samples`.  
+On entry: if no root is set, enters "selecting" sub-state — next note-on with a sample sets the root and triggers pre-computation.  
+Press **r** to re-select root.
+
+### trim
+Note on (with an existing sample) → selects that note, begins loop preview of full sample.  
+Two-step workflow:
+1. **Step 0** — adjust start point with arrow keys (fine: 0.1%, coarse: 1%), **Enter** to confirm
+2. **Step 1** — adjust end point with arrow keys, **Enter** to save the trimmed slice
+
+**Escape** in step 1 goes back to step 0. **Escape** in step 0 deselects.
+
+### copy
+Two-step note selection:
+1. Note on → sets `copy_source_note` (must have a sample)
+2. Note on → sets `copy_dest_note`; if dest already has a sample, prompts for confirmation (**Enter** to confirm, **Escape** to cancel)
+
+### loop
+Loop state machine: `idle → recording → playing → overdub → playing → ...`  
+Triggered by **l** key or sustain pedal (CC 64).  
+Sample voices (from note-on) are mixed into the loop buffer during recording and overdub.  
+**Escape** resets to idle.
+
+State transitions (`loop.py:cycle_loop_state`):
+- `idle` → `recording`: clears buffer, starts accumulating audio blocks
+- `recording` → `playing`: concatenates chunks into `loop_buffer`, starts playback
+- `playing` → `overdub`: incoming audio mixed (summed) into `loop_buffer` in real time
+- `overdub` → `playing`: increments `loop_layer_count`, returns to playback
+
+### split
+Splits one sample into multiple slices and assigns each to a MIDI note.  
+Two phases:
+- **markers**: select a source note, use arrow keys to position cursor, **Enter** to place a marker. **a** advances to assign phase.
+- **assign**: each note-on saves the current slice to that key and advances to the next. **Escape** steps back one slice (or back to markers phase).
+
+### config
+Up/Down navigates fields. Left/Right changes values. Fields: input device, output device, MIDI port, synesthesia toggle. Changes saved immediately on each key press.
+
+## Audio Callback
+
+`audio_callback` runs on a real-time background thread (called by sounddevice). It holds `voices_lock` for the entire block.
+
+Priority order inside the callback:
+1. **trim** loop preview (if `trim_looping`)
+2. **split** loop preview (if `split_looping`)
+3. **loop** mode — sample voices + loop buffer capture/playback/overdub
+4. **sample / pitch / chromatic** — sample voice playback
+5. **synth** — additive synthesis
+
+Metronome is mixed in at the end of blocks 3–5 when `metronome_enabled` and the current mode is in `METRONOME_MODES`.
+
+## Key Behaviors
+
+### Note release
+| Input source | Synth mode | Sample/pitch/chromatic modes |
+|---|---|---|
+| MIDI note-off | Triggers fade-out (`releasing=True`) | Triggers fade-out |
+| Keyboard mock | Auto note-off after 250ms (`KEYBOARD_NOTE_RELEASE_S`) | No auto note-off — sample plays to end |
+
+### Sustain pedal (CC 64)
+- In **synth**: holds notes; releasing pedal fades all held notes
+- In **loop**: cycles loop state (same as **l** key)
+- Other modes: ignored
+
+### Metronome
+- **m** key toggles on/off in modes: `synth`, `sample`, `record`, `loop`, `chromatic`
+- Arrow keys adjust BPM (±1 / ±5) when metronome is on and no mode-specific arrow binding takes priority
+- BPM range: 20–300
+
+## State Locking
+
+`state.voices_lock` is shared between:
+- `audio_callback` (audio thread) — holds lock for entire block
+- `midi_callback` (MIDI thread) — holds lock briefly for voice mutations
+- `app.py` main loop — holds lock for loop state transitions and some mode resets
+
+All mutations to `voices`, `sample_voices`, `loop_buffer`, `loop_state`, and related fields must happen under this lock.
+
+## Persistence
+
+| Data | Location |
+|------|----------|
+| Samples | `samples/note_<midi>.wav` (16-bit mono, 48kHz) |
+| Pitch offsets | `samples/pitch_offsets.json` |
+| Config (devices, synesthesia) | `~/.config/midi_cli/config.json` |

midi_cli-0.2.0/CLAUDE.md

@@ -0,0 +1,5 @@
+# midi-cli
+
+See [ARCHITECTURE.md](ARCHITECTURE.md) for a full developer reference: modes, key behaviors, app flow, state locking, and persistence.
+
+When making changes that affect modes, key bindings, audio behavior, state, or persistence, update ARCHITECTURE.md to reflect the new behavior.

{midi_cli-0.1.3 → midi_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: midi-cli
-Version: 0.1.3
+Version: 0.2.0
 Summary: A MIDI sampler and looper in your terminal
 Project-URL: Homepage, https://github.com/mnbpdx/midi-cli
 Project-URL: Repository, https://github.com/mnbpdx/midi-cli

{midi_cli-0.1.3 → midi_cli-0.2.0}/midi_cli/app.py

@@ -11,9 +11,15 @@ import midi_cli.state as st
 from midi_cli.audio import audio_callback
 from midi_cli.sampler import load_samples, load_pitch_offsets, save_sample, adjust_pitch, compute_chromatic_samples_async, execute_copy, stop_recording
 from midi_cli.midi import open_midi_input, trigger_keyboard_note, midi_callback
-from midi_cli.ui import draw_ui, reset_trim_state, reset_copy_state, reset_split_state
+from midi_cli.ui import draw_ui, reset_trim_state, reset_copy_state
 from midi_cli.loop import reset_loop_state, cycle_loop_state
 
+def _stop_active_voices():
+    """Clear all active voices on mode switch."""
+    with st.voices_lock:
+        st.sample_voices.clear()
+        st.voices.clear()
+
 
 def main():
     from midi_cli.config import load_defaults, get_input_devices, get_output_devices, get_midi_ports, save_config
@@ -61,15 +67,17 @@ def main():
                 if ch in ("q", "\x03"):  # q or Ctrl+C
                     break
                 elif ch == "\r" and st.mode == "split" and st.split_selected_note is not None and st.split_phase == "markers":
-                    st.split_markers.append(st.split_cursor_pos)
-                    st.split_markers.sort()
-                    # Restart loop from start of new region (last marker → end)
-                    st.split_loop_pos = 0
+                    with st.voices_lock:
+                        st.split_markers.append(st.split_cursor_pos)
+                        st.split_markers.sort()
+                        # Restart loop from start of new region (last marker → end)
+                        st.split_loop_pos = 0
                 elif ch == "\r" and st.mode == "trim" and st.trim_selected_note is not None:
                     if st.trim_step == 0:
                         # Confirm start, advance to end adjustment
                         st.trim_step = 1
-                        st.trim_loop_pos = st.trim_start
+                        with st.voices_lock:
+                            st.trim_loop_pos = st.trim_start
                     else:
                         # Confirm end, slice and save
                         audio = st.samples[st.trim_selected_note][st.trim_start:st.trim_end]
@@ -91,10 +99,11 @@ def main():
                     if st.mode == "copy":
                         reset_copy_state()
                     if st.mode == "split":
-                        reset_split_state()
+                        st.reset_split_state()
                     if st.mode == "loop":
                         with st.voices_lock:
                             reset_loop_state()
+                    _stop_active_voices()
                     st.mode = st.MODES[(st.MODES.index(st.mode) + 1) % len(st.MODES)]
                     if st.mode == "chromatic":
                         st.chromatic_selecting = st.chromatic_root_note is None
@@ -108,7 +117,8 @@ def main():
                         if st.mode == "trim" and st.trim_selected_note is not None:
                             if st.trim_step == 1:
                                 st.trim_step = 0
-                                st.trim_loop_pos = st.trim_start
+                                with st.voices_lock:
+                                    st.trim_loop_pos = st.trim_start
                             else:
                                 reset_trim_state()
                         elif st.mode == "copy" and (st.copy_source_note is not None or st.copy_confirm_pending):
@@ -120,14 +130,17 @@ def main():
                             if st.split_phase == "assign":
                                 if st.split_current_slice > 0:
                                     st.split_current_slice -= 1
-                                    st.split_loop_pos = 0
+                                    with st.voices_lock:
+                                        st.split_loop_pos = 0
                                 else:
                                     st.split_phase = "markers"
-                                    st.split_looping = False
+                                    with st.voices_lock:
+                                        st.split_looping = False
                             else:
                                 # markers phase
                                 if st.split_markers:
-                                    st.split_markers.pop()
+                                    with st.voices_lock:
+                                        st.split_markers.pop()
                                 else:
                                     st.split_selected_note = None
                     else:
@@ -142,10 +155,11 @@ def main():
                             if st.mode == "copy":
                                 reset_copy_state()
                             if st.mode == "split":
-                                reset_split_state()
+                                st.reset_split_state()
                             if st.mode == "loop":
                                 with st.voices_lock:
                                     reset_loop_state()
+                            _stop_active_voices()
                             st.mode = st.MODES[(st.MODES.index(st.mode) - 1) % len(st.MODES)]
                             if st.mode == "chromatic":
                                 st.chromatic_selecting = st.chromatic_root_note is None
@@ -255,14 +269,28 @@ def main():
                                     "midi_port": st.midi_port,
                                     "synesthesia_enabled": st.synesthesia_enabled,
                                 })
+                        elif st.metronome_enabled and st.mode in st.METRONOME_MODES:
+                            if seq == "[C":    # Right: +1 BPM
+                                st.bpm = min(st.BPM_MAX, st.bpm + 1)
+                            elif seq == "[D":  # Left: -1 BPM
+                                st.bpm = max(st.BPM_MIN, st.bpm - 1)
+                            elif seq == "[A":  # Up: +5 BPM
+                                st.bpm = min(st.BPM_MAX, st.bpm + 5)
+                            elif seq == "[B":  # Down: -5 BPM
+                                st.bpm = max(st.BPM_MIN, st.bpm - 5)
                 elif ch == 'a' and st.mode == "split" and st.split_selected_note is not None and st.split_phase == "markers" and st.split_markers:
                     st.split_phase = "assign"
                     st.split_current_slice = 0
-                    st.split_loop_pos = 0
-                    st.split_looping = True
+                    with st.voices_lock:
+                        st.split_loop_pos = 0
+                        st.split_looping = True
                 elif ch == 'l' and st.mode == "loop":
                     with st.voices_lock:
                         cycle_loop_state()
+                elif ch == 'm' and st.mode in st.METRONOME_MODES:
+                    with st.voices_lock:
+                        st.metronome_enabled = not st.metronome_enabled
+                        st.metronome_pos = 0
                 elif st.keyboard_mock_mode and ch in st.KEYBOARD_NOTE_MAP:
                     trigger_keyboard_note(st.KEYBOARD_NOTE_MAP[ch])
                 elif st.keyboard_mock_mode and ch == '`':

{midi_cli-0.1.3 → midi_cli-0.2.0}/midi_cli/audio.py

@@ -2,6 +2,11 @@ import numpy as np
 
 import midi_cli.state as st
 
+_CLICK_DUR = 0.012  # 12ms
+_CLICK_FREQ = 1000.0
+_t = np.linspace(0, _CLICK_DUR, int(st.SAMPLE_RATE * _CLICK_DUR), endpoint=False)
+_CLICK_BUFFER = (np.sin(2 * np.pi * _CLICK_FREQ * _t) * np.exp(-_t * 300) * 0.7).astype(np.float64)
+
 
 def build_synth_envelope(gain, releasing, faded_in, age, frames):
     """Vectorized envelope: returns (gains_array, new_gain, new_age, new_faded_in)."""
@@ -74,6 +79,45 @@ def build_synth_envelope(gain, releasing, faded_in, age, frames):
     return gains, new_gain, new_age, faded_in
 
 
+def _mix_sample_voices(frames, mix):
+    finished = []
+    for note, sv in st.sample_voices.items():
+        if st.mode == "chromatic":
+            sample_data = st.chromatic_samples.get(note)
+            if sample_data is None:
+                finished.append(note)
+                continue
+        else:
+            if note not in st.samples:
+                finished.append(note)
+                continue
+            ps = st.pitched_samples.get(note)
+            sample_data = ps if ps is not None else st.samples.get(note)
+        pos = sv["pos"]
+        gain = sv["gain"]
+        releasing = sv["releasing"]
+        remaining = len(sample_data) - pos
+        n = min(frames, remaining)
+        if n <= 0:
+            finished.append(note)
+            continue
+        buf = np.zeros(frames)
+        buf[:n] = sample_data[pos:pos + n] * gain
+        if releasing:
+            fade_gains = np.maximum(0.0, gain - st.FADE_OUT_STEP * (np.arange(n) + 1))
+            buf[:n] *= fade_gains
+            gain = max(0.0, gain - st.FADE_OUT_STEP * n)
+        else:
+            gain = min(1.0, gain + st.FADE_IN_STEP * n)
+        mix += buf
+        sv["pos"] = pos + n
+        sv["gain"] = gain
+        if (releasing and gain <= 0.0) or pos + n >= len(sample_data):
+            finished.append(note)
+    for note in finished:
+        del st.sample_voices[note]
+
+
 def audio_callback(outdata, frames, time_info, status):
     with st.voices_lock:
         if st.mode == "trim" and st.trim_looping and st.trim_selected_note is not None:
@@ -161,36 +205,7 @@ def audio_callback(outdata, frames, time_info, status):
         if st.mode == "loop":
             mix = np.zeros(frames)
 
-            # Sample voice mixing (same logic as sample mode)
-            finished = []
-            for note, sv in st.sample_voices.items():
-                if note not in st.samples:
-                    finished.append(note)
-                    continue
-                pos = sv["pos"]
-                gain = sv["gain"]
-                releasing = sv["releasing"]
-                sample_data = st.samples[note]
-                remaining = len(sample_data) - pos
-                n = min(frames, remaining)
-                if n <= 0:
-                    finished.append(note)
-                    continue
-                buf = np.zeros(frames)
-                buf[:n] = sample_data[pos:pos + n] * gain
-                if releasing:
-                    fade_gains = np.maximum(0.0, gain - st.FADE_OUT_STEP * (np.arange(n) + 1))
-                    buf[:n] *= fade_gains
-                    gain = max(0.0, gain - st.FADE_OUT_STEP * n)
-                else:
-                    gain = min(1.0, gain + st.FADE_IN_STEP * n)
-                mix += buf
-                sv["pos"] = pos + n
-                sv["gain"] = gain
-                if (releasing and gain <= 0.0) or pos + n >= len(sample_data):
-                    finished.append(note)
-            for note in finished:
-                del st.sample_voices[note]
+            _mix_sample_voices(frames, mix)
 
             # Loop capture/playback
             if st.loop_state == "recording":
@@ -213,59 +228,36 @@ def audio_callback(outdata, frames, time_info, status):
                 mix += loop_chunk
                 st.loop_pos = (st.loop_pos + frames) % buf_len
 
+            if st.metronome_enabled and st.mode in st.METRONOME_MODES:
+                spb = int(st.SAMPLE_RATE * 60.0 / st.bpm)
+                click_len = len(_CLICK_BUFFER)
+                for i in range(frames):
+                    beat_pos = (st.metronome_pos + i) % spb
+                    if beat_pos < click_len:
+                        mix[i] += _CLICK_BUFFER[beat_pos]
+                st.metronome_pos = (st.metronome_pos + frames) % spb
+
             mix *= 0.25
             np.clip(mix, -1.0, 1.0, out=mix)
             outdata[:, 0] = mix
             return
 
         if st.mode in ("sample", "pitch", "chromatic", "trim"):
-            if not st.sample_voices:
+            if not st.sample_voices and not (st.metronome_enabled and st.mode in st.METRONOME_MODES):
                 outdata[:] = 0
                 return
 
             mix = np.zeros(frames)
-            finished = []
-
-            for note, sv in st.sample_voices.items():
-                if st.mode == "chromatic":
-                    sample_data = st.chromatic_samples.get(note)
-                    if sample_data is None:
-                        finished.append(note)
-                        continue
-                else:
-                    if note not in st.samples:
-                        finished.append(note)
-                        continue
-                    ps = st.pitched_samples.get(note)
-                    sample_data = ps if ps is not None else st.samples.get(note)
-                pos = sv["pos"]
-                gain = sv["gain"]
-                releasing = sv["releasing"]
-
-                remaining = len(sample_data) - pos
-                n = min(frames, remaining)
-                if n <= 0:
-                    finished.append(note)
-                    continue
-
-                buf = np.zeros(frames)
-                buf[:n] = sample_data[pos:pos + n] * gain
-
-                if releasing:
-                    fade_gains = np.maximum(0.0, gain - st.FADE_OUT_STEP * (np.arange(n) + 1))
-                    buf[:n] *= fade_gains
-                    gain = max(0.0, gain - st.FADE_OUT_STEP * n)
-                else:
-                    gain = min(1.0, gain + st.FADE_IN_STEP * n)
-
-                mix += buf
-                sv["pos"] = pos + n
-                sv["gain"] = gain
-                if (releasing and gain <= 0.0) or pos + n >= len(sample_data):
-                    finished.append(note)
+            _mix_sample_voices(frames, mix)
 
-            for note in finished:
-                del st.sample_voices[note]
+            if st.metronome_enabled and st.mode in st.METRONOME_MODES:
+                spb = int(st.SAMPLE_RATE * 60.0 / st.bpm)
+                click_len = len(_CLICK_BUFFER)
+                for i in range(frames):
+                    beat_pos = (st.metronome_pos + i) % spb
+                    if beat_pos < click_len:
+                        mix[i] += _CLICK_BUFFER[beat_pos]
+                st.metronome_pos = (st.metronome_pos + frames) % spb
 
             mix *= 0.25
             np.clip(mix, -1.0, 1.0, out=mix)
@@ -273,7 +265,7 @@ def audio_callback(outdata, frames, time_info, status):
             return
 
         # Synth mode
-        if not st.voices:
+        if not st.voices and not (st.metronome_enabled and st.mode in st.METRONOME_MODES):
             outdata[:] = 0
             return
 
@@ -307,6 +299,15 @@ def audio_callback(outdata, frames, time_info, status):
         for note in finished:
             del st.voices[note]
 
+        if st.metronome_enabled and st.mode in st.METRONOME_MODES:
+            spb = int(st.SAMPLE_RATE * 60.0 / st.bpm)
+            click_len = len(_CLICK_BUFFER)
+            for i in range(frames):
+                beat_pos = (st.metronome_pos + i) % spb
+                if beat_pos < click_len:
+                    mix[i] += _CLICK_BUFFER[beat_pos]
+            st.metronome_pos = (st.metronome_pos + frames) % spb
+
         mix *= 0.25  # fixed headroom (up to ~4 voices at full level)
         np.clip(mix, -1.0, 1.0, out=mix)
         outdata[:, 0] = mix

{midi_cli-0.1.3 → midi_cli-0.2.0}/midi_cli/midi.py

@@ -51,8 +51,7 @@ def midi_callback(event, data):
                     st.split_current_slice += 1
                     st.split_loop_pos = 0
                     if st.split_current_slice >= len(slices):
-                        from midi_cli.ui import reset_split_state
-                        reset_split_state()
+                        st.reset_split_state()
             return
 
         if st.mode == "copy":
@@ -78,17 +77,19 @@ def midi_callback(event, data):
                     st.pitch_selected_note = note
             return
         if st.mode == "chromatic":
-            if st.chromatic_selecting:
-                if note in st.samples:
-                    st.chromatic_root_note = note
-                    with st.voices_lock:
+            should_compute = False
+            with st.voices_lock:
+                if st.chromatic_selecting:
+                    if note in st.samples:
+                        st.chromatic_root_note = note
                         st.sample_voices.clear()
-                    st.chromatic_selecting = False
-                    compute_chromatic_samples_async(note)
-            else:
-                with st.voices_lock:
+                        st.chromatic_selecting = False
+                        should_compute = True
+                else:
                     if note in st.chromatic_samples:
                         st.sample_voices[note] = {"pos": 0, "releasing": False, "gain": 1.0}
+            if should_compute:
+                compute_chromatic_samples_async(note)
             return
         with st.voices_lock:
             if st.mode in ("sample", "loop"):

{midi_cli-0.1.3 → midi_cli-0.2.0}/midi_cli/state.py

@@ -17,11 +17,12 @@ KEYBOARD_NOTE_RELEASE_S = 0.25
 RST = "\033[0m"
 DIM = "\033[2m"
 BOLD = "\033[1m"
-GREEN = "\033[32m"
+GREEN = "\033[38;5;65m"
 RED = "\033[31m"
 YELLOW = "\033[33m"
 CYAN = "\033[36m"
 ORANGE = "\033[38;5;208m"
+SLATE = "\033[38;5;66m"
 CLEAR_LINE = "\033[2K"
 
 NOTE_SYNESTHESIA_COLORS = {
@@ -118,6 +119,21 @@ split_current_slice = 0      # which slice is being assigned
 split_loop_pos = 0           # audio preview playback position
 split_looping = False        # True while preview loop is active
 
+
+def reset_split_state():
+    """Reset all split mode state back to selection."""
+    global split_selected_note, split_markers, split_phase
+    global split_cursor_pos, split_current_slice, split_loop_pos, split_looping
+    split_selected_note = None
+    split_markers = []
+    split_phase = "markers"
+    split_cursor_pos = 0
+    split_current_slice = 0
+    with voices_lock:
+        split_loop_pos = 0
+        split_looping = False
+
+
 # Loop mode state
 loop_state = "idle"       # "idle", "recording", "playing", "overdub"
 loop_buffer = None        # np.ndarray once recorded, None when idle
@@ -125,6 +141,15 @@ loop_pos = 0              # current playback position (int)
 loop_record_chunks = []   # list of np.ndarray, accumulated during recording
 loop_layer_count = 0      # 1 after first recording, increments each overdub completion
 
+METRONOME_MODES = {"synth", "sample", "record", "loop", "chromatic"}
+
+# Metronome state
+metronome_enabled = False
+bpm = 120.0
+metronome_pos = 0   # sample counter, wraps every beat
+BPM_MIN = 20.0
+BPM_MAX = 300.0
+
 # Copy mode state
 copy_source_note = None       # MIDI note selected as source
 copy_dest_note = None         # MIDI note selected as destination

{midi_cli-0.1.3 → midi_cli-0.2.0}/midi_cli/ui.py

@@ -20,59 +20,24 @@ def _synesthesia_color(note_name):
     return st.NOTE_SYNESTHESIA_COLORS.get(pc, "")
 
 
-def render_waveform(note):
-    """Render a centered ASCII waveform of the sample with trim region highlighted."""
-    audio = st.samples.get(note)
-    if audio is None:
-        return []
-    cols = os.get_terminal_size().columns - 2  # leave margin
-    cols = max(10, cols)
-    n = len(audio)
-    rows = st.TRIM_WAVEFORM_HEIGHT
-    half = rows / 2  # rows above/below center (float for smooth mapping)
-    blocks = " \u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588"
-    blocks_rev = " \u2594\u2594\u2580\u2580\u2580\u2580\u2588\u2588"
-
-    # Compute peak amplitude per column bin
+def _render_waveform_core(audio, cols, rows, color_fn):
     peaks = np.zeros(cols)
+    n = len(audio)
     for c in range(cols):
         start = c * n // cols
         end = (c + 1) * n // cols
         if start < end:
             peaks[c] = np.max(np.abs(audio[start:end]))
-
     max_peak = np.max(peaks) if np.max(peaks) > 0 else 1.0
 
-    # Compute which columns are inside the trim region
-    trim_start_col = st.trim_start * cols // n if n > 0 else 0
-    trim_end_col = (st.trim_end * cols + n - 1) // n if n > 0 else cols  # ceiling
-
-    # Active marker column
-    if st.trim_step == 0:
-        marker_col = trim_start_col
-    else:
-        marker_col = min(trim_end_col - 1, cols - 1)
-
-    # Playback position column (only during audio, not silence padding)
-    region_len = st.trim_end - st.trim_start
-    if region_len > 0 and st.trim_looping and st.trim_loop_pos < region_len:
-        play_offset = st.trim_loop_pos
-        play_col = trim_start_col + play_offset * (trim_end_col - trim_start_col) // region_len
-        play_col = max(trim_start_col, min(play_col, trim_end_col - 1))
-    else:
-        play_col = -1
-
-    WHITE = "\033[97m"
-
+    blocks = " \u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588"
+    blocks_rev = " \u2594\u2594\u2580\u2580\u2580\u2580\u2588\u2588"
+    half = rows / 2
     lines = []
     for row in range(rows):
-        # Center is between row half-1 and half
-        # Upper half: rows 0..half-1 (top row = max amplitude)
-        # Lower half: rows half..rows-1 (bottom row = max amplitude)
-        dist_from_center = abs(row - half + 0.5) / half  # 0 at center, 1 at edges
+        dist_from_center = abs(row - half + 0.5) / half
         threshold_low = dist_from_center
         threshold_high = dist_from_center + 1.0 / half
-
         is_upper = row < half
         line = " "
         for c in range(cols):
@@ -82,93 +47,62 @@ def render_waveform(note):
             else:
                 frac = min(1.0, (level - threshold_low) / (threshold_high - threshold_low))
                 idx = int(frac * (len(blocks) - 1))
-                if is_upper:
-                    char = blocks[idx]
-                else:
-                    # Bottom half: use reversed blocks so fill grows from top of cell
-                    char = blocks_rev[idx]
-
-            in_region = trim_start_col <= c < trim_end_col
-            is_boundary = c == trim_start_col or c == trim_end_col - 1
-            if c == play_col:
-                head = char if char.strip() else "\u2502"
-                line += f"{st.RED}{st.BOLD}{head}{st.RST}"
-            elif is_boundary:
-                bar = char if char.strip() else "\u2502"
-                if c == marker_col:
-                    line += f"{st.ORANGE}{st.BOLD}{bar}{st.RST}"
-                else:
-                    line += f"{st.CYAN}{bar}{st.RST}"
-            elif in_region:
-                line += f"{st.CYAN}{char}{st.RST}"
-            else:
-                line += f"{st.DIM}{char}{st.RST}"
+                char = blocks[idx] if is_upper else blocks_rev[idx]
+            line += color_fn(c, char)
         lines.append(line)
     return lines
 
 
-def render_loop_waveform(audio, loop_state, loop_pos, loop_layer_count):
-    """Render a 6-row waveform for loop mode with colored playhead."""
-    cols = os.get_terminal_size().columns - 2
-    cols = max(10, cols)
+def render_waveform(note):
+    """Render a centered ASCII waveform of the sample with trim region highlighted."""
+    audio = st.samples.get(note)
+    if audio is None:
+        return []
+    cols = max(10, os.get_terminal_size().columns - 2)
     n = len(audio)
-    rows = st.TRIM_WAVEFORM_HEIGHT
-    half = rows / 2
-    blocks = " \u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588"
-    blocks_rev = " \u2594\u2594\u2580\u2580\u2580\u2580\u2588\u2588"
+    trim_start_col = st.trim_start * cols // n if n > 0 else 0
+    trim_end_col = (st.trim_end * cols + n - 1) // n if n > 0 else cols
+    marker_col = trim_start_col if st.trim_step == 0 else min(trim_end_col - 1, cols - 1)
+    region_len = st.trim_end - st.trim_start
+    if region_len > 0 and st.trim_looping and st.trim_loop_pos < region_len:
+        play_col = trim_start_col + st.trim_loop_pos * (trim_end_col - trim_start_col) // region_len
+        play_col = max(trim_start_col, min(play_col, trim_end_col - 1))
+    else:
+        play_col = -1
 
-    # Compute peak amplitude per column bin
-    peaks = np.zeros(cols)
-    for c in range(cols):
-        start = c * n // cols
-        end = (c + 1) * n // cols
-        if start < end:
-            peaks[c] = np.max(np.abs(audio[start:end]))
+    def color_fn(c, char):
+        if c == play_col:
+            head = char if char.strip() else "\u2502"
+            return f"{st.RED}{st.BOLD}{head}{st.RST}"
+        if c == trim_start_col or c == trim_end_col - 1:
+            bar = char if char.strip() else "\u2502"
+            if c == marker_col:
+                return f"{st.ORANGE}{st.BOLD}{bar}{st.RST}"
+            return f"{st.CYAN}{bar}{st.RST}"
+        if trim_start_col <= c < trim_end_col:
+            return f"{st.CYAN}{char}{st.RST}"
+        return f"{st.DIM}{char}{st.RST}"
 
-    max_peak = np.max(peaks) if np.max(peaks) > 0 else 1.0
+    return _render_waveform_core(audio, cols, st.TRIM_WAVEFORM_HEIGHT, color_fn)
 
-    # Color by state
-    if loop_state == "recording":
-        color = st.RED
-    elif loop_state == "overdub":
-        color = st.YELLOW
-    else:
-        color = st.GREEN
 
-    # Playhead column (only during playing/overdub)
+def render_loop_waveform(audio, loop_state, loop_pos, loop_layer_count):
+    """Render a 6-row waveform for loop mode with colored playhead."""
+    cols = max(10, os.get_terminal_size().columns - 2)
+    n = len(audio)
+    color = st.RED if loop_state == "recording" else st.YELLOW if loop_state == "overdub" else st.GREEN
     if loop_state in ("playing", "overdub") and n > 0:
-        play_col = loop_pos * cols // n
-        play_col = max(0, min(play_col, cols - 1))
+        play_col = max(0, min(loop_pos * cols // n, cols - 1))
     else:
         play_col = -1
 
-    lines = []
-    for row in range(rows):
-        dist_from_center = abs(row - half + 0.5) / half
-        threshold_low = dist_from_center
-        threshold_high = dist_from_center + 1.0 / half
-
-        is_upper = row < half
-        line = " "
-        for c in range(cols):
-            level = peaks[c] / max_peak
-            if level <= threshold_low:
-                char = " "
-            else:
-                frac = min(1.0, (level - threshold_low) / (threshold_high - threshold_low))
-                idx = int(frac * (len(blocks) - 1))
-                if is_upper:
-                    char = blocks[idx]
-                else:
-                    char = blocks_rev[idx]
+    def color_fn(c, char):
+        if c == play_col:
+            head = char if char.strip() else "\u2502"
+            return f"{st.RED}{st.BOLD}{head}{st.RST}"
+        return f"{color}{char}{st.RST}"
 
-            if c == play_col:
-                head = char if char.strip() else "\u2502"
-                line += f"{st.RED}{st.BOLD}{head}{st.RST}"
-            else:
-                line += f"{color}{char}{st.RST}"
-        lines.append(line)
-    return lines
+    return _render_waveform_core(audio, cols, st.TRIM_WAVEFORM_HEIGHT, color_fn)
 
 
 def reset_trim_state():
@@ -177,19 +111,10 @@ def reset_trim_state():
     st.trim_step = 0
     st.trim_start = 0
     st.trim_end = 0
-    st.trim_loop_pos = 0
-    st.trim_looping = False
-
+    with st.voices_lock:
+        st.trim_loop_pos = 0
+        st.trim_looping = False
 
-def reset_split_state():
-    """Reset all split mode state back to selection."""
-    st.split_selected_note = None
-    st.split_markers = []
-    st.split_phase = "markers"
-    st.split_cursor_pos = 0
-    st.split_current_slice = 0
-    st.split_loop_pos = 0
-    st.split_looping = False
 
 
 def render_split_waveform(note):
@@ -197,81 +122,50 @@ def render_split_waveform(note):
     audio = st.samples.get(note)
     if audio is None:
         return []
-    cols = os.get_terminal_size().columns - 2
-    cols = max(10, cols)
+    cols = max(10, os.get_terminal_size().columns - 2)
     n = len(audio)
-    rows = st.TRIM_WAVEFORM_HEIGHT
-    half = rows / 2
-    blocks = " \u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588"
-    blocks_rev = " \u2594\u2594\u2580\u2580\u2580\u2580\u2588\u2588"
-
-    peaks = np.zeros(cols)
-    for c in range(cols):
-        start = c * n // cols
-        end = (c + 1) * n // cols
-        if start < end:
-            peaks[c] = np.max(np.abs(audio[start:end]))
-
-    max_peak = np.max(peaks) if np.max(peaks) > 0 else 1.0
 
     if st.split_phase == "markers":
         cursor_col = st.split_cursor_pos * cols // n if n > 0 else 0
         marker_cols = set(m * cols // n for m in st.split_markers if n > 0)
-
-        # Playhead column — loop_pos is relative to last marker (or 0)
+        sorted_marker_cols = sorted(marker_cols)
         region_start = st.split_markers[-1] if st.split_markers else 0
         abs_play_pos = region_start + st.split_loop_pos
-        if st.split_looping and n > 0 and abs_play_pos < n:
-            play_col = abs_play_pos * cols // n
-        else:
-            play_col = -1
+        play_col = (abs_play_pos * cols // n) if st.split_looping and n > 0 and abs_play_pos < n else -1
+        parity = len(st.split_markers) % 2
+        right_color = st.CYAN if parity == 0 else st.SLATE
+        left_color = st.SLATE if parity == 0 else st.CYAN
+        num_regions = len(st.split_markers) + 1
 
-        lines = []
-        for row in range(rows):
-            dist_from_center = abs(row - half + 0.5) / half
-            threshold_low = dist_from_center
-            threshold_high = dist_from_center + 1.0 / half
-            is_upper = row < half
-            line = " "
-            for c in range(cols):
-                level = peaks[c] / max_peak
-                if level <= threshold_low:
-                    char = " "
-                else:
-                    frac = min(1.0, (level - threshold_low) / (threshold_high - threshold_low))
-                    idx = int(frac * (len(blocks) - 1))
-                    char = blocks[idx] if is_upper else blocks_rev[idx]
-
-                if c == play_col:
-                    head = char if char.strip() else "\u2502"
-                    line += f"{st.RED}{st.BOLD}{head}{st.RST}"
-                elif c == cursor_col:
-                    bar = char if char.strip() else "\u2502"
-                    line += f"{st.ORANGE}{st.BOLD}{bar}{st.RST}"
-                elif c in marker_cols:
-                    bar = char if char.strip() else "\u2502"
-                    line += f"{st.CYAN}{bar}{st.RST}"
-                else:
-                    line += f"{st.DIM}{char}{st.RST}"
-            lines.append(line)
-        return lines
-    else:
-        # Assign phase: highlight current slice, dim others, show boundaries in orange
+        def color_fn(c, char):
+            if c == play_col:
+                head = char if char.strip() else "\u2502"
+                return f"{st.RED}{st.BOLD}{head}{st.RST}"
+            if c == cursor_col:
+                bar = char if char.strip() else "\u2502"
+                return f"{st.ORANGE}{st.BOLD}{bar}{st.RST}"
+            if c in marker_cols:
+                bar = char if char.strip() else "\u2502"
+                return f"{st.CYAN}{bar}{st.RST}"
+            ridx = sum(1 for mc in sorted_marker_cols if mc <= c)
+            if ridx == num_regions - 1:
+                color = st.DIM if c > cursor_col else left_color
+            else:
+                color = st.SLATE if ridx % 2 == 0 else st.CYAN
+            return f"{color}{char}{st.RST}"
+
+    else:  # assign phase
         slices = get_split_slices()
         if not slices or st.split_current_slice >= len(slices):
             return []
         sl_start, sl_end = slices[st.split_current_slice]
         sl_start_col = sl_start * cols // n if n > 0 else 0
         sl_end_col = (sl_end * cols + n - 1) // n if n > 0 else cols
-
-        # All boundary columns
         all_boundaries = set()
         for s, e in slices:
             if n > 0:
                 all_boundaries.add(s * cols // n)
                 all_boundaries.add(min((e * cols + n - 1) // n, cols - 1))
-
-        # Playback position column
         region_len = sl_end - sl_start
         if region_len > 0 and st.split_looping and st.split_loop_pos < region_len:
             play_col = sl_start_col + st.split_loop_pos * (sl_end_col - sl_start_col) // region_len
@@ -279,35 +173,18 @@ def render_split_waveform(note):
         else:
             play_col = -1
 
-        lines = []
-        for row in range(rows):
-            dist_from_center = abs(row - half + 0.5) / half
-            threshold_low = dist_from_center
-            threshold_high = dist_from_center + 1.0 / half
-            is_upper = row < half
-            line = " "
-            for c in range(cols):
-                level = peaks[c] / max_peak
-                if level <= threshold_low:
-                    char = " "
-                else:
-                    frac = min(1.0, (level - threshold_low) / (threshold_high - threshold_low))
-                    idx = int(frac * (len(blocks) - 1))
-                    char = blocks[idx] if is_upper else blocks_rev[idx]
-
-                in_slice = sl_start_col <= c < sl_end_col
-                if c == play_col:
-                    head = char if char.strip() else "\u2502"
-                    line += f"{st.RED}{st.BOLD}{head}{st.RST}"
-                elif c in all_boundaries:
-                    bar = char if char.strip() else "\u2502"
-                    line += f"{st.ORANGE}{bar}{st.RST}"
-                elif in_slice:
-                    line += f"{st.CYAN}{char}{st.RST}"
-                else:
-                    line += f"{st.DIM}{char}{st.RST}"
-            lines.append(line)
-        return lines
+        def color_fn(c, char):
+            if c == play_col:
+                head = char if char.strip() else "\u2502"
+                return f"{st.RED}{st.BOLD}{head}{st.RST}"
+            if c in all_boundaries:
+                bar = char if char.strip() else "\u2502"
+                return f"{st.ORANGE}{bar}{st.RST}"
+            if sl_start_col <= c < sl_end_col:
+                return f"{st.YELLOW}{char}{st.RST}"
+            return f"{st.SLATE}{char}{st.RST}"
+
+    return _render_waveform_core(audio, cols, st.TRIM_WAVEFORM_HEIGHT, color_fn)
 
 
 def render_config_panel():
@@ -547,6 +424,8 @@ def draw_ui():
         line1 += f"{st.YELLOW}{st.BOLD}\u25cf{st.RST}"
     else:
         line1 += f"{st.DIM}\u25cb{st.RST}"
+    if st.metronome_enabled and st.mode in st.METRONOME_MODES:
+        line1 += f"  {st.CYAN}{st.BOLD}\u2669 {st.bpm:.0f}{st.RST}"
     out += _line(line1)
 
     # Line 2: MIDI controller name or keyboard mode hint
@@ -567,8 +446,10 @@ def draw_ui():
     elif st.mode == "chromatic":
         if st.chromatic_selecting:
             line3 = f" {st.DIM}[Tab] mode  [play] select  [q] quit{st.RST}"
+        elif st.metronome_enabled:
+            line3 = f" {st.DIM}[Tab] mode  [m] metro off  [\u2190\u2192] bpm\u00b11  [\u2191\u2193] bpm\u00b15  [r] reselect  [q] quit{st.RST}"
         else:
-            line3 = f" {st.DIM}[Tab] mode  [r] reselect  [q] quit{st.RST}"
+            line3 = f" {st.DIM}[Tab] mode  [r] reselect  [m] metro  [q] quit{st.RST}"
     elif st.mode == "copy":
         if st.copy_confirm_pending:
             line3 = f" {st.DIM}[enter] confirm  [esc] cancel  [q] quit{st.RST}"
@@ -584,11 +465,18 @@ def draw_ui():
         else:
             line3 = f" {st.DIM}[play] assign slice  [esc] undo  [q] quit{st.RST}"
     elif st.mode == "loop":
-        line3 = f" {st.DIM}[sustain/l] record/play/dub  [esc] clear  [play] sample  [q] quit{st.RST}"
+        if st.metronome_enabled:
+            line3 = f" {st.DIM}[Tab] mode  [m] metro off  [\u2190\u2192] bpm\u00b11  [\u2191\u2193] bpm\u00b15  [q] quit{st.RST}"
+        else:
+            line3 = f" {st.DIM}[sustain/l] record/play/dub  [esc] clear  [play] sample  [m] metro  [q] quit{st.RST}"
     elif st.mode == "config":
         line3 = f" {st.DIM}[\u2191\u2193] field  [\u2190\u2192] change  [Tab] mode  [q] quit{st.RST}"
     else:
-        line3 = f" {st.DIM}[Tab] mode  [q] quit{st.RST}"
+        if st.metronome_enabled and st.mode in st.METRONOME_MODES:
+            line3 = f" {st.DIM}[Tab] mode  [m] metro off  [\u2190\u2192] bpm\u00b11  [\u2191\u2193] bpm\u00b15  [q] quit{st.RST}"
+        else:
+            metro_hint = "  [m] metro" if st.mode in st.METRONOME_MODES else ""
+            line3 = f" {st.DIM}[Tab] mode{metro_hint}  [q] quit{st.RST}"
     out += _line(line3)
 
     sys.stdout.write(out)

{midi_cli-0.1.3 → midi_cli-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "midi-cli"
-version = "0.1.3"
+version = "0.2.0"
 description = "A MIDI sampler and looper in your terminal"
 readme = "README.md"
 license = { text = "MIT" }

{midi_cli-0.1.3 → midi_cli-0.2.0}/uv.lock

@@ -74,7 +74,7 @@ wheels = [
 
 [[package]]
 name = "midi-cli"
-version = "0.1.2"
+version = "0.1.3"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },

midi_cli-0.1.3/.claude/settings.local.json

@@ -1,65 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(gh issue:*)",
-      "Bash(git:*)",
-      "Bash(python3 -c \"import rtmidi; print\\(rtmidi.__version__\\)\")",
-      "Bash(python3 -c \"import sounddevice; print\\(sounddevice.__version__\\)\")",
-      "Bash(python3 -c \"import numpy; print\\(numpy.__version__\\)\")",
-      "WebFetch(domain:spotlightkid.github.io)",
-      "WebFetch(domain:python-sounddevice.readthedocs.io)",
-      "Bash(python3 -m venv .venv)",
-      "Bash(source .venv/bin/activate)",
-      "Bash(pip install:*)",
-      "Bash(chmod:*)",
-      "Bash(ls /Users/mb/code/midi-cli/*.py /Users/mb/code/midi-cli/src/**/*.py)",
-      "Bash(gh pr:*)",
-      "Bash(wc -l /Users/mb/code/midi-cli/src/**/*.rs /Users/mb/code/midi-cli/src/*.rs)",
-      "Bash(grep -E \"\\\\.\\(py|txt\\)$\")",
-      "Bash(git commit:*)",
-      "Bash(ambiguous\". Use explicit None check instead.:*)",
-      "Bash(gh repo:*)",
-      "Bash(wc -l /Users/mb/code/midi-cli/src/*.py /Users/mb/code/midi-cli/*.py)",
-      "Bash(python3 -m py_compile main.py)",
-      "Bash(python3:*)",
-      "Bash(/Users/mb/code/midi-cli/.venv/bin/python -c \"import midi_cli.state; import midi_cli.audio; import midi_cli.sampler; import midi_cli.ui; import midi_cli.midi; import midi_cli.app; print\\('All imports OK'\\)\")",
-      "Bash(/Users/mb/code/midi-cli/.venv/bin/pip list:*)",
-      "Bash(/Users/mb/code/midi-cli/.venv/bin/python -c \"\nimport midi_cli.state as st\nprint\\(f'state: {len\\(st.MODES\\)} modes, SAMPLE_RATE={st.SAMPLE_RATE}'\\)\nimport midi_cli.audio\nprint\\(f'audio: audio_callback, build_synth_envelope, trim_silence OK'\\)\nprint\\('All non-pyrubberband imports OK'\\)\n\")",
-      "Bash(uv run:*)",
-      "Bash(wc -l /Users/mb/code/midi-cli/midi_cli/*.py /Users/mb/code/midi-cli/main.py)",
-      "Bash(python -m py_compile midi_cli/state.py)",
-      "Bash(python -m py_compile midi_cli/sampler.py)",
-      "Bash(python -m py_compile midi_cli/midi.py)",
-      "Bash(python -m py_compile midi_cli/ui.py)",
-      "Bash(python -m py_compile midi_cli/app.py)",
-      "Bash(brew search:*)",
-      "Bash(brew info:*)",
-      "WebSearch",
-      "Bash(python:*)",
-      "Bash(ls:*)",
-      "Bash(uv build:*)",
-      "Skill(update-config)",
-      "WebFetch(domain:docs.astral.sh)",
-      "Bash(source ~/.zshrc)",
-      "Bash(uv publish:*)",
-      "Bash(gh label:*)",
-      "Bash(wc:*)",
-      "WebFetch(domain:teenage.engineering)",
-      "WebFetch(domain:op-forums.com)",
-      "WebFetch(domain:www.sinesquares.net)",
-      "WebFetch(domain:www.soundonsound.com)",
-      "WebFetch(domain:www.morningdewmedia.com)",
-      "WebFetch(domain:www.elektronauts.com)",
-      "WebFetch(domain:musictech.com)",
-      "WebFetch(domain:www.musicradar.com)",
-      "WebFetch(domain:singularsound-publicly-downloadable.s3.us-east-2.amazonaws.com)",
-      "WebFetch(domain:www.chompiclub.com)",
-      "WebFetch(domain:www.macprovideo.com)",
-      "WebFetch(domain:cdn.roland.com)",
-      "WebFetch(domain:community.native-instruments.com)",
-      "WebFetch(domain:www.manualslib.com)",
-      "WebFetch(domain:modwiggler.com)",
-      "Bash(gh api:*)"
-    ]
-  }
-}

midi_cli-0.1.3/main.py

@@ -1,6 +0,0 @@
-#!/usr/bin/env -S uv run --project .
-"""Thin wrapper so ./main.py keeps working."""
-from midi_cli.app import main
-
-if __name__ == "__main__":
-    main()