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

{midi_cli-0.1.2 → midi_cli-0.1.3}/.claude/settings.local.json

@@ -43,7 +43,23 @@
       "Bash(source ~/.zshrc)",
       "Bash(uv publish:*)",
       "Bash(gh label:*)",
-      "Bash(wc:*)"
+      "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.2 → midi_cli-0.1.3}/.gitignore

@@ -6,4 +6,5 @@ venv/
 dist/
 build/
 samples/
+samples-*/
 config.json

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: midi-cli
-Version: 0.1.2
+Version: 0.1.3
 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
@@ -20,7 +20,10 @@ Description-Content-Type: text/markdown
 
 # midi-cli
 
-A little midi player in your terminal, tested in zsh on macOS.
+A little midi player in your terminal, tested in zsh on macOS. Vibe coded, obviously.
+
+<img width="3384" height="692" alt="image" src="https://github.com/user-attachments/assets/4e5ff869-447c-45d8-9b66-49052f340aed" />
+
 
 ## Install
 

midi_cli-0.1.3/README.md

@@ -0,0 +1,30 @@
+# midi-cli
+
+A little midi player in your terminal, tested in zsh on macOS. Vibe coded, obviously.
+
+<img width="3384" height="692" alt="image" src="https://github.com/user-attachments/assets/4e5ff869-447c-45d8-9b66-49052f340aed" />
+
+
+## Install
+
+```sh
+pipx install midi-cli
+```
+
+Or with pip:
+
+```sh
+pip install midi-cli
+```
+
+### For development
+
+```sh
+uv pip install -e .
+```
+
+## Usage
+
+```sh
+midi-cli
+```

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

@@ -11,24 +11,26 @@ 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
+from midi_cli.ui import draw_ui, reset_trim_state, reset_copy_state, reset_split_state
 from midi_cli.loop import reset_loop_state, cycle_loop_state
 
 
 def main():
-    from midi_cli.config import run_setup_wizard
-    cfg = run_setup_wizard()
+    from midi_cli.config import load_defaults, get_input_devices, get_output_devices, get_midi_ports, save_config
+    cfg = load_defaults()
     st.input_device = cfg.get("input_device")
     st.output_device = cfg.get("output_device")
     st.midi_port = cfg.get("midi_port")
-    sys.stdout.write("\033[2J\033[H")
-    sys.stdout.flush()
-
-    midi_in, port_name = open_midi_input(st.midi_port)
-    if midi_in is None:
+    st.synesthesia_enabled = cfg.get("synesthesia_enabled", True)
+    if st.midi_port is None:
+        midi_in = None
         st.keyboard_mock_mode = True
     else:
-        st.ui_midi_port = port_name
+        midi_in, port_name = open_midi_input(st.midi_port)
+        if midi_in is None:
+            st.keyboard_mock_mode = True
+        else:
+            st.ui_midi_port = port_name
 
     load_samples()
     load_pitch_offsets()
@@ -45,20 +47,24 @@ def main():
     fd = sys.stdin.fileno()
     old_settings = termios.tcgetattr(fd)
     sys.stdout.write(st.HIDE_CURSOR)
+    sys.stdout.write("\033[?1049h")   # enter alternate screen
     sys.stdout.flush()
 
     try:
         tty.setraw(fd)
-        initialized = False
         while True:
-            draw_ui(initialized)
-            initialized = True
+            draw_ui()
 
             ready, _, _ = select.select([fd], [], [], 0.05)
             if ready:
                 ch = os.read(fd, 1).decode("utf-8", errors="replace")
                 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
                 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
@@ -84,6 +90,8 @@ def main():
                         reset_trim_state()
                     if st.mode == "copy":
                         reset_copy_state()
+                    if st.mode == "split":
+                        reset_split_state()
                     if st.mode == "loop":
                         with st.voices_lock:
                             reset_loop_state()
@@ -98,12 +106,30 @@ def main():
                     if not esc_ready:
                         # Bare Escape
                         if st.mode == "trim" and st.trim_selected_note is not None:
-                            reset_trim_state()
+                            if st.trim_step == 1:
+                                st.trim_step = 0
+                                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):
                             reset_copy_state()
                         elif st.mode == "loop":
                             with st.voices_lock:
                                 reset_loop_state()
+                        elif st.mode == "split" and st.split_selected_note is not None:
+                            if st.split_phase == "assign":
+                                if st.split_current_slice > 0:
+                                    st.split_current_slice -= 1
+                                    st.split_loop_pos = 0
+                                else:
+                                    st.split_phase = "markers"
+                                    st.split_looping = False
+                            else:
+                                # markers phase
+                                if st.split_markers:
+                                    st.split_markers.pop()
+                                else:
+                                    st.split_selected_note = None
                     else:
                         seq = os.read(fd, 2).decode("utf-8", errors="replace")
                         if seq == "[Z":  # Shift+Tab: previous mode
@@ -115,6 +141,8 @@ def main():
                                 reset_trim_state()
                             if st.mode == "copy":
                                 reset_copy_state()
+                            if st.mode == "split":
+                                reset_split_state()
                             if st.mode == "loop":
                                 with st.voices_lock:
                                     reset_loop_state()
@@ -154,6 +182,84 @@ def main():
                                 adjust_pitch(st.pitch_selected_note, 0, st.CENTS_STEP)
                             elif seq == "[D":  # Left: -10 cents
                                 adjust_pitch(st.pitch_selected_note, 0, -st.CENTS_STEP)
+                        elif st.mode == "split" and st.split_selected_note is not None and st.split_phase == "markers":
+                            sample_len = len(st.samples[st.split_selected_note])
+                            fine = max(1, sample_len // 1000)
+                            coarse = max(1, sample_len // 100)
+                            if seq == "[C":    # Right: move cursor forward fine
+                                st.split_cursor_pos = min(sample_len - 1, st.split_cursor_pos + fine)
+                            elif seq == "[D":  # Left: move cursor back fine
+                                st.split_cursor_pos = max(0, st.split_cursor_pos - fine)
+                            elif seq == "[A":  # Up: move cursor forward coarse
+                                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 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
                 elif ch == 'l' and st.mode == "loop":
                     with st.voices_lock:
                         cycle_loop_state()
@@ -166,6 +272,7 @@ def main():
         pass
     finally:
         termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+        sys.stdout.write("\033[?1049l")  # exit alternate screen
         sys.stdout.write(st.SHOW_CURSOR)
         sys.stdout.flush()
         stream.stop()

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

@@ -111,6 +111,53 @@ def audio_callback(outdata, frames, time_info, status):
             outdata[:, 0] = mix
             return
 
+        if st.mode == "split" and st.split_looping and st.split_selected_note is not None:
+            sample_data = st.samples.get(st.split_selected_note)
+            if sample_data is None:
+                outdata[:] = 0
+                return
+
+            if st.split_phase == "markers":
+                # Loop from most recent marker to end of sample
+                region_start = st.split_markers[-1] if st.split_markers else 0
+                region_end = len(sample_data)
+            else:
+                from midi_cli.sampler import get_split_slices
+                slices = get_split_slices()
+                if not slices or st.split_current_slice >= len(slices):
+                    outdata[:] = 0
+                    return
+                region_start, region_end = slices[st.split_current_slice]
+
+            region_len = region_end - region_start
+            if region_len <= 0:
+                outdata[:] = 0
+                return
+            cycle_len = max(region_len, st.MIN_LOOP_PERIOD)
+            if st.split_loop_pos < 0 or st.split_loop_pos >= cycle_len:
+                st.split_loop_pos = 0
+            mix = np.zeros(frames)
+            written = 0
+            while written < frames:
+                if st.split_loop_pos < region_len:
+                    src_pos = region_start + st.split_loop_pos
+                    avail = region_len - st.split_loop_pos
+                    n = min(frames - written, avail)
+                    mix[written:written + n] = sample_data[src_pos:src_pos + n]
+                    st.split_loop_pos += n
+                    written += n
+                else:
+                    avail = cycle_len - st.split_loop_pos
+                    n = min(frames - written, avail)
+                    st.split_loop_pos += n
+                    written += n
+                if st.split_loop_pos >= cycle_len:
+                    st.split_loop_pos = 0
+            mix *= 0.25
+            np.clip(mix, -1.0, 1.0, out=mix)
+            outdata[:, 0] = mix
+            return
+
         if st.mode == "loop":
             mix = np.zeros(frames)
 

midi_cli-0.1.3/midi_cli/config.py

@@ -0,0 +1,103 @@
+import json
+import os
+
+import rtmidi
+import sounddevice as sd
+
+
+CONFIG_PATH = "config.json"
+
+
+def load_config():
+    """Read config.json; return empty dict if missing."""
+    if not os.path.isfile(CONFIG_PATH):
+        return {}
+    with open(CONFIG_PATH, "r") as f:
+        return json.load(f)
+
+
+def save_config(cfg):
+    """Write config.json."""
+    with open(CONFIG_PATH, "w") as f:
+        json.dump(cfg, f, indent=2)
+
+
+def _get_input_devices():
+    """Return input device names with the system default first."""
+    devs = sd.query_devices()
+    names = [d["name"] for d in devs if d["max_input_channels"] > 0]
+    try:
+        idx = sd.default.device[0]
+        if idx >= 0:
+            default_name = devs[idx]["name"]
+            if default_name in names:
+                names.remove(default_name)
+                names.insert(0, default_name)
+    except Exception:
+        pass
+    return names
+
+
+def _get_output_devices():
+    """Return output device names with the system default first."""
+    devs = sd.query_devices()
+    names = [d["name"] for d in devs if d["max_output_channels"] > 0]
+    try:
+        idx = sd.default.device[1]
+        if idx >= 0:
+            default_name = devs[idx]["name"]
+            if default_name in names:
+                names.remove(default_name)
+                names.insert(0, default_name)
+    except Exception:
+        pass
+    return names
+
+
+def get_input_devices():
+    """Return input device names with the system default first."""
+    return _get_input_devices()
+
+
+def get_output_devices():
+    """Return output device names with the system default first."""
+    return _get_output_devices()
+
+
+def get_midi_ports():
+    """Return available MIDI input port names."""
+    _tmp = rtmidi.MidiIn()
+    ports = _tmp.get_ports()
+    _tmp.delete()
+    return ports
+
+
+def load_defaults():
+    """
+    Load config.json and fill missing keys with system defaults.
+    Silently drops saved devices that are no longer available.
+    Returns config dict with input_device, output_device, midi_port, synesthesia_enabled.
+    """
+    cfg = load_config()
+
+    input_names = _get_input_devices()
+    saved_in = cfg.get("input_device")
+    if saved_in not in input_names:
+        saved_in = input_names[0] if input_names else None
+    cfg["input_device"] = saved_in
+
+    output_names = _get_output_devices()
+    saved_out = cfg.get("output_device")
+    if saved_out not in output_names:
+        saved_out = output_names[0] if output_names else None
+    cfg["output_device"] = saved_out
+
+    midi_ports = get_midi_ports()
+    if "midi_port" not in cfg:
+        cfg["midi_port"] = midi_ports[0] if midi_ports else None
+    elif cfg["midi_port"] is not None and cfg["midi_port"] not in midi_ports:
+        cfg["midi_port"] = None  # saved port gone; fall back to keyboard mode
+
+    cfg.setdefault("synesthesia_enabled", False)
+
+    return cfg

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

@@ -3,7 +3,7 @@ import threading
 import rtmidi
 
 import midi_cli.state as st
-from midi_cli.sampler import start_recording, stop_recording, compute_chromatic_samples_async, execute_copy
+from midi_cli.sampler import start_recording, stop_recording, compute_chromatic_samples_async, execute_copy, save_sample, get_split_slices
 from midi_cli.loop import cycle_loop_state
 
 
@@ -15,6 +15,9 @@ def midi_callback(event, data):
     status, note, velocity = message[0], message[1], message[2]
     msg_type = status & 0xF0
 
+    if msg_type in (0x90, 0x80):
+        st.seen_notes.add(note)
+
     if msg_type == 0x90 and velocity > 0:
         if st.mode == "record":
             threading.Thread(target=start_recording, args=(note,), daemon=True).start()
@@ -30,6 +33,28 @@ def midi_callback(event, data):
                 st.trim_looping = True
             return
 
+        if st.mode == "split":
+            if st.split_phase == "markers":
+                if st.split_selected_note is None and note in st.samples:
+                    st.split_selected_note = note
+                    st.split_cursor_pos = 0
+                    st.split_markers = []
+                    st.split_loop_pos = 0
+                    st.split_looping = True
+            else:
+                # Assign phase: save current slice to this key
+                slices = get_split_slices()
+                if slices and st.split_current_slice < len(slices):
+                    sl_start, sl_end = slices[st.split_current_slice]
+                    audio_slice = st.samples[st.split_selected_note][sl_start:sl_end].copy()
+                    save_sample(note, audio_slice)
+                    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()
+            return
+
         if st.mode == "copy":
             if st.copy_confirm_pending:
                 return
@@ -76,7 +101,7 @@ def midi_callback(event, data):
         if st.mode == "record":
             threading.Thread(target=stop_recording, args=(note,), daemon=True).start()
             return
-        if st.mode in ("trim", "copy"):
+        if st.mode in ("trim", "copy", "split"):
             return
         # Only clear if this note is still the active one
         note_name = st.midi_note_name(note)
@@ -122,7 +147,7 @@ def trigger_keyboard_note(note):
     if old:
         old.cancel()
     midi_callback(([0x90, note, 100], 0), None)
-    if st.mode in ("sample", "pitch", "chromatic", "trim", "copy", "loop"):
+    if st.mode in ("sample", "pitch", "chromatic", "trim", "copy", "loop", "split"):
         # Sample modes: one-shot, let the sample play to its natural end
         return
     if st.sustain:

{midi_cli-0.1.2 → midi_cli-0.1.3}/midi_cli/sampler.py

@@ -118,7 +118,9 @@ def save_sample(note_number, audio):
         wf.writeframes(int_data.tobytes())
 
     if note_number in st.pitch_offsets:
-        recompute_pitched_sample_async(note_number)
+        st.pitch_offsets.pop(note_number)
+        st.pitched_samples.pop(note_number, None)
+        save_pitch_offsets()
 
 
 def execute_copy():
@@ -192,6 +194,16 @@ def stop_recording(note_number):
         save_sample(note_number, audio)
 
 
+def get_split_slices():
+    """Return list of (start, end) sample index pairs based on split markers."""
+    note = st.split_selected_note
+    if note not in st.samples:
+        return []
+    n = len(st.samples[note])
+    boundaries = [0] + sorted(st.split_markers) + [n]
+    return [(boundaries[i], boundaries[i + 1]) for i in range(len(boundaries) - 1)]
+
+
 def load_samples():
     """Load any existing .wav files from ./samples/ directory."""
     if not os.path.isdir("samples"):

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

@@ -23,6 +23,21 @@ YELLOW = "\033[33m"
 CYAN = "\033[36m"
 ORANGE = "\033[38;5;208m"
 CLEAR_LINE = "\033[2K"
+
+NOTE_SYNESTHESIA_COLORS = {
+    "C":  "\033[38;5;196m",  # red
+    "C#": "\033[38;5;202m",  # red-orange
+    "D":  "\033[38;5;208m",  # orange
+    "D#": "\033[38;5;226m",  # yellow
+    "E":  "\033[38;5;154m",  # yellow-green
+    "F":  "\033[38;5;82m",   # green
+    "F#": "\033[38;5;48m",   # cyan-green
+    "G":  "\033[38;5;51m",   # cyan
+    "G#": "\033[38;5;33m",   # sky blue
+    "A":  "\033[38;5;63m",   # blue-violet
+    "A#": "\033[38;5;129m",  # purple
+    "B":  "\033[38;5;201m",  # magenta
+}
 HIDE_CURSOR = "\033[?25l"
 SHOW_CURSOR = "\033[?25h"
 NUM_UI_LINES = 4
@@ -60,7 +75,7 @@ sustain = False
 sustained_notes = set()
 
 # Sampler state
-MODES = ["synth", "sample", "record", "pitch", "chromatic", "trim", "copy", "loop"]
+MODES = ["synth", "sample", "record", "pitch", "chromatic", "trim", "copy", "loop", "split", "config"]
 mode = "synth"
 samples = {}  # note_number -> numpy array (mono float64)
 sample_voices = {}  # note -> {"pos": int, "releasing": bool, "gain": float}
@@ -94,6 +109,15 @@ TRIM_WAVEFORM_HEIGHT = 6    # rows for waveform display
 MIN_TRIM_SAMPLES = 480      # ~10ms minimum trim length
 MIN_LOOP_PERIOD = int(2.0 * SAMPLE_RATE)  # minimum loop cycle including silence
 
+# Split mode state
+split_selected_note = None   # source MIDI note
+split_markers = []           # sorted sample indices (split points)
+split_phase = "markers"      # "markers" or "assign"
+split_cursor_pos = 0         # cursor position while placing markers
+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
+
 # Loop mode state
 loop_state = "idle"       # "idle", "recording", "playing", "overdub"
 loop_buffer = None        # np.ndarray once recorded, None when idle
@@ -106,14 +130,19 @@ copy_source_note = None       # MIDI note selected as source
 copy_dest_note = None         # MIDI note selected as destination
 copy_confirm_pending = False  # True when awaiting overwrite confirmation
 
+# Config mode state
+config_focused_field = 0   # 0=input, 1=output, 2=midi, 3=synesthesia
+
+# UI settings
+synesthesia_enabled = False
+
 # UI state
 ui_active_note = None
 ui_sustain = False
 ui_recording = None  # None or {"note": str, "start_time": float}
 ui_midi_port = ""
-prev_ui_lines = NUM_UI_LINES
-
 keyboard_mock_mode = False
+seen_notes = set()       # MIDI note numbers observed this session (for range detection)
 keyboard_timers = {}  # note -> threading.Timer, for pending note-offs
 
 # Device selections (set by startup wizard, None = system default / port 0)