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

{midi_cli-0.2.0 → midi_cli-0.3.0}/ARCHITECTURE.md

@@ -30,12 +30,14 @@ Developer reference for midi-cli: modes, key behavior, and app flow.
 Modes are stored in `state.mode`. The ordered list is defined in `state.MODES`:
 
 ```
-synth → sample → record → pitch → chromatic → trim → copy → loop → split → config
+synth → sample → pitch → chromatic → trim → copy → loop → split
 ```
 
 - **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
+- Switching away from `trim`, `copy`, `split`, or `loop` resets that mode's transient state
+- **`r`** is a global key toggle (arm/disarm recording) — not a mode
+- **`c`** opens the config overlay — not a mode
 
 ### synth
 Polyphonic additive synth (5 harmonics, piano-like two-stage decay).  
@@ -46,10 +48,12 @@ Sustain pedal (CC 64) holds notes until pedal release.
 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).
+### Record armed (`r` key)
+`record_armed` is a boolean flag in state, not a mode. Press **r** to arm (yellow ARM indicator appears); press **r** again to disarm.  
+While armed: note on → `start_recording()`, note off → `stop_recording()`.  
+In keyboard mock mode: key press toggles recording on/off per-note via `keyboard_recording_notes`.  
+Tabbing away while armed automatically disarms and stops any active recording.  
+In chromatic mode, **r** means "reselect root" — it does not arm recording.
 
 ### pitch
 Note on → plays the sample and sets `pitch_selected_note`.  
@@ -76,7 +80,7 @@ Two-step note selection:
 
 ### loop
 Loop state machine: `idle → recording → playing → overdub → playing → ...`  
-Triggered by **l** key or sustain pedal (CC 64).  
+Triggered by **l** key.  
 Sample voices (from note-on) are mixed into the loop buffer during recording and overdub.  
 **Escape** resets to idle.
 
@@ -92,8 +96,10 @@ 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.
+### Config overlay (`c` key)
+Press **c** from any mode to open the config overlay (rendered in the waveform area). All keys except **q** are swallowed while the overlay is open.  
+Up/Down navigates fields. Left/Right changes values. Fields: input device, output device, MIDI port, synesthesia toggle. Changes saved immediately on each arrow press.  
+Press **c** or **Escape** to close the overlay. Focus always resets to field 0 on open.
 
 ## Audio Callback
 
@@ -118,11 +124,10 @@ Metronome is mixed in at the end of blocks 3–5 when `metronome_enabled` and th
 
 ### 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`
+- **m** key toggles on/off in modes: `synth`, `sample`, `loop`, `chromatic`
 - Arrow keys adjust BPM (±1 / ±5) when metronome is on and no mode-specific arrow binding takes priority
 - BPM range: 20–300
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: midi-cli
-Version: 0.2.0
+Version: 0.3.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.2.0 → midi_cli-0.3.0}/midi_cli/app.py

@@ -14,6 +14,26 @@ 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
 from midi_cli.loop import reset_loop_state, cycle_loop_state
 
+def _read_escape_seq(fd):
+    seq = [os.read(fd, 1).decode("utf-8", errors="replace")]
+    if seq[0] == 'O':
+        r, _, _ = select.select([fd], [], [], 0.02)
+        if r:
+            seq.append(os.read(fd, 1).decode("utf-8", errors="replace"))
+    elif seq[0] == '[':
+        while True:
+            r, _, _ = select.select([fd], [], [], 0.02)
+            if not r:
+                break
+            b = os.read(fd, 1).decode("utf-8", errors="replace")
+            seq.append(b)
+            if b.isalpha() or b == '~':
+                break
+            if len(seq) > 16:
+                break
+    return "".join(seq)
+
+
 def _stop_active_voices():
     """Clear all active voices on mode switch."""
     with st.voices_lock:
@@ -66,6 +86,78 @@ def main():
                 ch = os.read(fd, 1).decode("utf-8", errors="replace")
                 if ch in ("q", "\x03"):  # q or Ctrl+C
                     break
+                elif st.config_overlay_open:
+                    if ch == "c":
+                        st.config_overlay_open = False
+                    elif ch == "\x1b":
+                        esc_ready, _, _ = select.select([fd], [], [], 0.02)
+                        if not esc_ready:
+                            st.config_overlay_open = False
+                        else:
+                            seq = _read_escape_seq(fd)
+                            if seq == "[Z":  # Shift+Tab: ignore while overlay open
+                                pass
+                            elif seq == "[A":  # Up: previous field
+                                st.config_focused_field = (st.config_focused_field - 1) % 4
+                            elif seq == "[B":  # Down: next field
+                                st.config_focused_field = (st.config_focused_field + 1) % 4
+                            elif seq in ("[C", "[D"):  # Right/Left: change value
+                                direction = 1 if seq == "[C" else -1
+                                field = st.config_focused_field
+                                if field == 3:  # Synesthesia toggle
+                                    st.synesthesia_enabled = not st.synesthesia_enabled
+                                elif field == 0:  # Input device
+                                    devices = get_input_devices()
+                                    if devices:
+                                        cur = st.input_device
+                                        idx = devices.index(cur) if cur in devices else 0
+                                        st.input_device = devices[(idx + direction) % len(devices)]
+                                elif field == 1:  # Output device
+                                    devices = get_output_devices()
+                                    if devices:
+                                        cur = st.output_device
+                                        idx = devices.index(cur) if cur in devices else 0
+                                        new_device = devices[(idx + direction) % len(devices)]
+                                        stream.stop()
+                                        stream.close()
+                                        st.output_device = new_device
+                                        stream = sd.OutputStream(
+                                            samplerate=st.SAMPLE_RATE,
+                                            blocksize=st.BLOCK_SIZE,
+                                            channels=1,
+                                            callback=audio_callback,
+                                            device=st.output_device,
+                                        )
+                                        stream.start()
+                                elif field == 2:  # MIDI port
+                                    ports = get_midi_ports()
+                                    options = [None] + ports
+                                    cur = st.midi_port
+                                    idx = options.index(cur) if cur in options else 0
+                                    new_port = options[(idx + direction) % len(options)]
+                                    if midi_in is not None:
+                                        midi_in.close_port()
+                                        midi_in.delete()
+                                        midi_in = None
+                                    st.midi_port = new_port
+                                    if new_port is None:
+                                        st.keyboard_mock_mode = True
+                                        st.ui_midi_port = ""
+                                    else:
+                                        midi_in, port_name = open_midi_input(new_port)
+                                        if midi_in is None:
+                                            st.keyboard_mock_mode = True
+                                            st.ui_midi_port = ""
+                                        else:
+                                            st.keyboard_mock_mode = False
+                                            st.ui_midi_port = port_name
+                                save_config({
+                                    "input_device": st.input_device,
+                                    "output_device": st.output_device,
+                                    "midi_port": st.midi_port,
+                                    "synesthesia_enabled": st.synesthesia_enabled,
+                                })
+                    # all other keys are silently swallowed by the overlay
                 elif ch == "\r" and st.mode == "split" and st.split_selected_note is not None and st.split_phase == "markers":
                     with st.voices_lock:
                         st.split_markers.append(st.split_cursor_pos)
@@ -90,7 +182,8 @@ def main():
                 elif ch == "\r" and st.mode == "copy" and st.copy_confirm_pending:
                     execute_copy()
                 elif ch == "\t":  # Tab: next mode
-                    if st.mode == "record":
+                    if st.record_armed:
+                        st.record_armed = False
                         st.keyboard_recording_notes.clear()
                         if st.recording_note is not None:
                             threading.Thread(target=stop_recording, args=(st.recording_note,), daemon=True).start()
@@ -109,6 +202,17 @@ def main():
                         st.chromatic_selecting = st.chromatic_root_note is None
                 elif ch == "r" and st.mode == "chromatic" and not st.chromatic_selecting:
                     st.chromatic_selecting = True
+                elif ch == "r" and st.mode == "sample":
+                    if st.record_armed:
+                        st.record_armed = False
+                        st.keyboard_recording_notes.clear()
+                        if st.recording_note is not None:
+                            threading.Thread(target=stop_recording, args=(st.recording_note,), daemon=True).start()
+                    else:
+                        st.record_armed = True
+                elif ch == "c":
+                    st.config_overlay_open = True
+                    st.config_focused_field = 0
                 elif ch == "\x1b":  # escape sequence
                     # Use select on fd with timeout to distinguish bare Escape from sequences
                     esc_ready, _, _ = select.select([fd], [], [], 0.02)
@@ -144,9 +248,14 @@ def main():
                                 else:
                                     st.split_selected_note = None
                     else:
-                        seq = os.read(fd, 2).decode("utf-8", errors="replace")
+                        # Read a complete VT escape sequence. F5-F10 send CSI
+                        # sequences like \x1b[15~ (5 bytes); reading only 2
+                        # bytes would leak digits into the next iteration and
+                        # trigger unintended notes via KEYBOARD_NOTE_MAP.
+                        seq = _read_escape_seq(fd)
                         if seq == "[Z":  # Shift+Tab: previous mode
-                            if st.mode == "record":
+                            if st.record_armed:
+                                st.record_armed = False
                                 st.keyboard_recording_notes.clear()
                                 if st.recording_note is not None:
                                     threading.Thread(target=stop_recording, args=(st.recording_note,), daemon=True).start()
@@ -208,67 +317,6 @@ def main():
                                 st.split_cursor_pos = min(sample_len - 1, st.split_cursor_pos + coarse)
                             elif seq == "[B":  # Down: move cursor back coarse
                                 st.split_cursor_pos = max(0, st.split_cursor_pos - coarse)
-                        elif st.mode == "config":
-                            if seq == "[A":  # Up: previous field
-                                st.config_focused_field = (st.config_focused_field - 1) % 4
-                            elif seq == "[B":  # Down: next field
-                                st.config_focused_field = (st.config_focused_field + 1) % 4
-                            elif seq in ("[C", "[D"):  # Right/Left: change value
-                                direction = 1 if seq == "[C" else -1
-                                field = st.config_focused_field
-                                if field == 3:  # Synesthesia toggle
-                                    st.synesthesia_enabled = not st.synesthesia_enabled
-                                elif field == 0:  # Input device
-                                    devices = get_input_devices()
-                                    if devices:
-                                        cur = st.input_device
-                                        idx = devices.index(cur) if cur in devices else 0
-                                        st.input_device = devices[(idx + direction) % len(devices)]
-                                elif field == 1:  # Output device
-                                    devices = get_output_devices()
-                                    if devices:
-                                        cur = st.output_device
-                                        idx = devices.index(cur) if cur in devices else 0
-                                        new_device = devices[(idx + direction) % len(devices)]
-                                        stream.stop()
-                                        stream.close()
-                                        st.output_device = new_device
-                                        stream = sd.OutputStream(
-                                            samplerate=st.SAMPLE_RATE,
-                                            blocksize=st.BLOCK_SIZE,
-                                            channels=1,
-                                            callback=audio_callback,
-                                            device=st.output_device,
-                                        )
-                                        stream.start()
-                                elif field == 2:  # MIDI port
-                                    ports = get_midi_ports()
-                                    options = [None] + ports
-                                    cur = st.midi_port
-                                    idx = options.index(cur) if cur in options else 0
-                                    new_port = options[(idx + direction) % len(options)]
-                                    if midi_in is not None:
-                                        midi_in.close_port()
-                                        midi_in.delete()
-                                        midi_in = None
-                                    st.midi_port = new_port
-                                    if new_port is None:
-                                        st.keyboard_mock_mode = True
-                                        st.ui_midi_port = ""
-                                    else:
-                                        midi_in, port_name = open_midi_input(new_port)
-                                        if midi_in is None:
-                                            st.keyboard_mock_mode = True
-                                            st.ui_midi_port = ""
-                                        else:
-                                            st.keyboard_mock_mode = False
-                                            st.ui_midi_port = port_name
-                                save_config({
-                                    "input_device": st.input_device,
-                                    "output_device": st.output_device,
-                                    "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)

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

@@ -19,7 +19,7 @@ def midi_callback(event, data):
         st.seen_notes.add(note)
 
     if msg_type == 0x90 and velocity > 0:
-        if st.mode == "record":
+        if st.record_armed:
             threading.Thread(target=start_recording, args=(note,), daemon=True).start()
             return
 
@@ -99,7 +99,7 @@ def midi_callback(event, data):
                 st.voices[note] = {"phase": 0.0, "gain": 0.0, "releasing": False, "age": 0, "faded_in": False}
                 st.sustained_notes.discard(note)
     elif msg_type == 0x80 or (msg_type == 0x90 and velocity == 0):
-        if st.mode == "record":
+        if st.record_armed:
             threading.Thread(target=stop_recording, args=(note,), daemon=True).start()
             return
         if st.mode in ("trim", "copy", "split"):
@@ -121,10 +121,6 @@ def midi_callback(event, data):
     elif msg_type == 0xB0 and note == 64:
         pedal_on = velocity >= 64
         st.ui_sustain = pedal_on
-        if pedal_on and st.mode == "loop":
-            with st.voices_lock:
-                cycle_loop_state()
-            return
         with st.voices_lock:
             st.sustain = pedal_on
             if not pedal_on:
@@ -135,7 +131,7 @@ def midi_callback(event, data):
 
 
 def trigger_keyboard_note(note):
-    if st.mode == "record":
+    if st.record_armed:
         if note in st.keyboard_recording_notes:
             st.keyboard_recording_notes.discard(note)
             threading.Thread(target=stop_recording, args=(note,), daemon=True).start()

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

@@ -76,7 +76,7 @@ sustain = False
 sustained_notes = set()
 
 # Sampler state
-MODES = ["synth", "sample", "record", "pitch", "chromatic", "trim", "copy", "loop", "split", "config"]
+MODES = ["synth", "sample", "pitch", "chromatic", "trim", "copy", "loop", "split"]
 mode = "synth"
 samples = {}  # note_number -> numpy array (mono float64)
 sample_voices = {}  # note -> {"pos": int, "releasing": bool, "gain": float}
@@ -86,6 +86,7 @@ recording_note = None       # int: MIDI note currently recording, or None
 recording_chunks = []       # list of np.ndarray frames from InputStream callback
 recording_stream = None     # sd.InputStream instance, or None
 keyboard_recording_notes = set()  # notes with in-progress keyboard-toggle recordings
+record_armed = False   # True when 'r' has been pressed; next note-on triggers recording
 
 # Pitch mode state
 pitch_offsets = {}        # note_number -> {"semitones": int, "cents": int}
@@ -141,7 +142,7 @@ 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_MODES = {"synth", "sample", "loop", "chromatic"}
 
 # Metronome state
 metronome_enabled = False
@@ -157,6 +158,7 @@ copy_confirm_pending = False  # True when awaiting overwrite confirmation
 
 # Config mode state
 config_focused_field = 0   # 0=input, 1=output, 2=midi, 3=synesthesia
+config_overlay_open = False   # True when config overlay is visible
 
 # UI settings
 synesthesia_enabled = False

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

@@ -296,7 +296,12 @@ def draw_ui():
         return s
 
     # Waveform area — always exactly waveform_block lines so the console never moves
-    if st.mode == "trim" and st.trim_selected_note is not None:
+    if st.config_overlay_open:
+        config_lines = render_config_panel()
+        for cl in config_lines:
+            out += _line(cl)
+        out += _line()
+    elif st.mode == "trim" and st.trim_selected_note is not None:
         waveform_lines = render_waveform(st.trim_selected_note)
         for wl in waveform_lines:
             out += _line(wl)
@@ -311,11 +316,6 @@ def draw_ui():
         for wl in waveform_lines:
             out += _line(wl)
         out += _line()
-    elif st.mode == "config":
-        config_lines = render_config_panel()
-        for cl in config_lines:
-            out += _line(cl)
-        out += _line()
     else:
         pad_lines = render_pad_strip(sounding_notes)
         for pl in pad_lines:
@@ -411,6 +411,8 @@ def draw_ui():
             line1 += f" {st.YELLOW}{st.BOLD}[DUB]{st.RST}  {st.DIM}{pos_m}:{pos_s:04.1f} / {buf_secs:.1f}  x{l_layers} {layer_word}{st.RST}"
         else:
             line1 += f" {st.DIM}idle{st.RST}"
+    elif st.mode == "sample" and st.record_armed and not ui_rec:
+        line1 += f" {st.YELLOW}{st.BOLD}\u25cf ARM{st.RST}"
     elif ui_rec:
         elapsed = time.time() - ui_rec["start_time"]
         line1 += f" {st.RED}{st.BOLD}\u25cf REC {ui_rec['note']}  {elapsed:.1f}s{st.RST}"
@@ -436,47 +438,49 @@ def draw_ui():
     out += _line(line2)
 
     # Line 3: help keys
-    if st.mode == "trim":
+    if st.config_overlay_open:
+        line3 = f" {st.DIM}[\u2191\u2193] field  [\u2190\u2192] change  [c] close  [q] quit{st.RST}"
+    elif st.mode == "trim":
         if st.trim_selected_note is None:
-            line3 = f" {st.DIM}[Tab] mode  [play] select  [q] quit{st.RST}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config  [play] select  [q] quit{st.RST}"
         else:
-            line3 = f" {st.DIM}[\u2190\u2192] fine  [\u2191\u2193] coarse  [enter] set  [esc] cancel  [q] quit{st.RST}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config  [\u2190\u2192] fine  [\u2191\u2193] coarse  [enter] set  [esc] cancel  [q] quit{st.RST}"
     elif st.mode == "pitch":
-        line3 = f" {st.DIM}[Tab] mode  [\u2191\u2193] semitone  [\u2190\u2192] cents  [q] quit{st.RST}"
+        line3 = f" {st.DIM}[Tab] mode  [c] config  [\u2191\u2193] semitone  [\u2190\u2192] cents  [q] quit{st.RST}"
     elif st.mode == "chromatic":
         if st.chromatic_selecting:
-            line3 = f" {st.DIM}[Tab] mode  [play] select  [q] quit{st.RST}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config  [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}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config  [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  [m] metro  [q] quit{st.RST}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config  [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}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config  [enter] confirm  [esc] cancel  [q] quit{st.RST}"
         elif st.copy_source_note is not None:
-            line3 = f" {st.DIM}[Tab] mode  [play] paste  [esc] cancel  [q] quit{st.RST}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config  [play] paste  [esc] cancel  [q] quit{st.RST}"
         else:
-            line3 = f" {st.DIM}[Tab] mode  [play] select  [q] quit{st.RST}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config  [play] select  [q] quit{st.RST}"
     elif st.mode == "split":
         if st.split_selected_note is None:
-            line3 = f" {st.DIM}[Tab] mode  [play] select  [q] quit{st.RST}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config  [play] select  [q] quit{st.RST}"
         elif st.split_phase == "markers":
-            line3 = f" {st.DIM}[\u2190\u2192] fine  [\u2191\u2193] coarse  [enter] mark  [a] assign  [esc] undo  [q] quit{st.RST}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config  [\u2190\u2192] fine  [\u2191\u2193] coarse  [enter] mark  [a] assign  [esc] undo  [q] quit{st.RST}"
         else:
-            line3 = f" {st.DIM}[play] assign slice  [esc] undo  [q] quit{st.RST}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config  [play] assign slice  [esc] undo  [q] quit{st.RST}"
     elif st.mode == "loop":
         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}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config  [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}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config  [l] record/play/dub  [esc] clear  [m] metro  [q] quit{st.RST}"
     else:
+        # synth or sample
+        rec_hint = "  [r] rec" if st.mode == "sample" else ""
         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}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config{rec_hint}  [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}"
+            line3 = f" {st.DIM}[Tab] mode  [c] config{rec_hint}{metro_hint}  [q] quit{st.RST}"
     out += _line(line3)
 
     sys.stdout.write(out)

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

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

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

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