vibeaudio 0.5.0 → 0.6.2

package/src/interactive.js

@@ -52,7 +52,48 @@ const GENRES = [
   { name: "🎲 Shuffle / Random", desc: "Picks a surprise vibe each time", id: "random" }
 ];
 
-function selectMenu(title, items, renderItem) {
+
+/**
+ * One loop of a genre, started from inside the menu and replaced on each
+ * press. Non-blocking: the menu stays interactive while it plays, so you can
+ * page through the list and hear each one.
+ *
+ * The process is module-level rather than per-menu because there is only ever
+ * one pair of speakers - a second press has to silence the first, or two
+ * genres play over each other.
+ */
+let previewChild = null;
+
+function stopPreview() {
+  if (!previewChild) return;
+  try {
+    previewChild.kill();
+  } catch (e) {
+    // Already gone - the loop ended on its own.
+  }
+  previewChild = null;
+}
+
+function playPreview(genreId) {
+  const { spawn } = require("child_process");
+  const { detectPlayer, getAudioPath, resolveGenre, normalizeVolume, loadConfig, playbackDisabled } = require("./player");
+
+  stopPreview();
+  // A muted user pressing "p" is asking to hear something, the same as
+  // `--preview` is - but a mute set for a call should still hold. Silence is
+  // the safe read, and --status says why.
+  if (playbackDisabled()) return;
+
+  const backend = detectPlayer();
+  if (!backend) return;
+
+  const volume = normalizeVolume(loadConfig().volume, 0.4);
+  const file = getAudioPath(resolveGenre(genreId), 2);
+  previewChild = spawn(backend.cmd, backend.args(file, volume), { stdio: "ignore" });
+  previewChild.on("error", () => { previewChild = null; });
+}
+
+function selectMenu(title, items, renderItem, { onPreview = null } = {}) {
   return new Promise((resolve) => {
     let selected = 0;
     const stdin = process.stdin;
@@ -92,6 +133,15 @@ function selectMenu(title, items, renderItem) {
         process.exit(0);
       }
 
+      // Auditioning is the whole reason the genre list is hard to choose from:
+      // nine names and a one-line description each, and no way to hear any of
+      // them without leaving the menu. A loop renders in ~150ms, so this is
+      // just a keypress.
+      if (onPreview && (key === "p" || key === "P")) {
+        onPreview(items[selected]);
+        return;
+      }
+
       if (key === "\u001b[A") {
         // Up arrow
         selected = (selected - 1 + items.length) % items.length;
@@ -119,6 +169,7 @@ function selectMenu(title, items, renderItem) {
     }
 
     function cleanup() {
+      if (onPreview) stopPreview();
       stdin.removeListener("data", onData);
       stdin.setRawMode(false);
       stdin.pause();
@@ -299,9 +350,10 @@ async function promptInteractive({ hooksInstalledFor = () => false } = {}) {
 
   // 3. Select Music Genre
   const selectedGenre = await selectMenu(
-    "Choose your sound vibe:",
+    "Choose your sound vibe:  \x1b[0m\x1b[90m(press p to hear the highlighted one)\x1b[0m",
     GENRES,
-    (item, num) => `${num}. ${item.name} \x1b[90m— ${item.desc}\x1b[0m`
+    (item, num) => `${num}. ${item.name} \x1b[90m— ${item.desc}\x1b[0m`,
+    { onPreview: (item) => playPreview(item.id) }
   );
 
   // 4. Select Volume Preset
@@ -335,4 +387,4 @@ async function promptInteractive({ hooksInstalledFor = () => false } = {}) {
   };
 }
 
-module.exports = { promptInteractive, tokenizeCommand, isInstalled, hookTargetOf, AI_TOOLS };
+module.exports = { promptInteractive, tokenizeCommand, isInstalled, hookTargetOf, playPreview, stopPreview, AI_TOOLS };

package/src/mcp.js

@@ -6,7 +6,7 @@
  */
 
 const readline = require("readline");
-const { AudioPlayer, AVAILABLE_GENRES, normalizeVolume, playbackDisabled, isKnownGenre } = require("./player");
+const { AudioPlayer, AVAILABLE_GENRES, normalizeVolume, playbackDisabled, isKnownGenre, loadConfig } = require("./player");
 const pkg = require("../package.json");
 
 // A desktop client that crashes never sends vibe_stop, so playback needs its
@@ -132,7 +132,12 @@ function handleMessage(player, msg) {
     const { name, arguments: args = {} } = params || {};
 
     if (name === "vibe_play") {
-      const requested = args.genre || process.env.VIBE_GENRE || "lofi";
+      // Same precedence as the CLI: what the model asked for, then the
+      // environment, then the user's saved default, then lofi. Reading the
+      // saved file here is what makes `vibe --genre jazz` mean jazz in a
+      // desktop client too, rather than only in the terminal.
+      const saved = loadConfig();
+      const requested = args.genre || process.env.VIBE_GENRE || saved.genre || "lofi";
       // An unknown genre already fell back to lofi inside the generator, but
       // player.genre kept the name nobody implements - so the model told the
       // user it was playing something that does not exist.
@@ -140,7 +145,8 @@ function handleMessage(player, msg) {
       // Both the tool argument and the env default go through the same parser
       // as the CLI, so a mistyped VIBE_VOLUME falls back instead of reaching
       // the player as NaN.
-      const volume = normalizeVolume(args.volume, normalizeVolume(process.env.VIBE_VOLUME, 0.4));
+      const volume = normalizeVolume(args.volume,
+        normalizeVolume(process.env.VIBE_VOLUME, normalizeVolume(saved.volume, 0.4)));
 
       const started = player.start(genre, volume, { maxDurationMs: MAX_PLAYBACK_MS });
       // start() returns false for three unrelated reasons, and the model

package/src/player.js

@@ -361,6 +361,98 @@ function setMuted(muted, minutes = DEFAULT_MUTE_MINUTES) {
   return state;
 }
 
+/**
+ * Saved defaults, and the reason there is a file for them at all.
+ *
+ * Genre and volume used to live in three unrelated places - an env var the
+ * wrapper read, a value baked into each hook's command line at install time,
+ * and an MCP client's `env` block - so "set my genre" had three different
+ * answers depending on how VibeAudio was being run, and the hooks' answer was
+ * "reinstall". A file every entry point reads at playback time collapses that
+ * to one: `vibe --genre jazz` means jazz everywhere, on the next prompt.
+ *
+ * Precedence is the conventional one - an explicit flag beats an env var beats
+ * this file beats the built-in default - so nothing that used to work stops
+ * working, and a one-off `--genre zen` stays a one-off.
+ */
+const CONFIG_FILE = path.join(os.homedir(), ".vibeaudio", "config.json");
+
+function loadConfig() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+    // A hand-edited file is the user's, not ours to reject: an unusable value
+    // falls through to the next source rather than taking playback down.
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch (e) {
+    return {};
+  }
+}
+
+/**
+ * Merges `patch` into the saved config. Written to a temp file and renamed, so
+ * a hook firing mid-write reads either the old file or the new one - never the
+ * half of one that happened to be on disk.
+ */
+function saveConfig(patch) {
+  const next = { ...loadConfig(), ...patch };
+  for (const key of Object.keys(next)) {
+    if (next[key] === null || next[key] === undefined) delete next[key];
+  }
+  fs.mkdirSync(path.dirname(CONFIG_FILE), { recursive: true });
+  const tmp = `${CONFIG_FILE}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}\n`);
+  fs.renameSync(tmp, CONFIG_FILE);
+  return next;
+}
+
+/**
+ * Per-directory overrides, kept in the same file under `projects`.
+ *
+ * The seed already makes each repo sound like itself; this is the same idea
+ * for the choice of instrument - zen in the docs repo, synthwave in the game -
+ * and it is opt-in, because a global default is what most people want.
+ *
+ * Resolved by walking up from `cwd`, so running an agent from a subdirectory
+ * still finds the setting saved at the repo root. Walking rather than matching
+ * exactly is the difference between a feature and a puzzle: `projectSeed()`
+ * keys on the exact directory and a subdirectory quietly gets its own
+ * arrangement, which is tolerable for a seed nobody chose and would not be for
+ * a genre somebody did.
+ */
+function projectSettings(config = loadConfig(), cwd = process.cwd()) {
+  const projects = config.projects;
+  if (!projects || typeof projects !== "object") return {};
+
+  let dir = path.resolve(cwd);
+  for (;;) {
+    const entry = projects[dir];
+    if (entry && typeof entry === "object") return entry;
+    const parent = path.dirname(dir);
+    if (parent === dir) return {}; // Reached the filesystem root.
+    dir = parent;
+  }
+}
+
+/**
+ * Saves `patch` under the current directory. A key whose value is null is
+ * removed, and a project left with no settings drops out of the file rather
+ * than sitting there as an empty object.
+ */
+function saveProjectConfig(patch, cwd = process.cwd()) {
+  const dir = path.resolve(cwd);
+  const config = loadConfig();
+  const projects = { ...(config.projects || {}) };
+  const entry = { ...(projects[dir] || {}), ...patch };
+
+  for (const key of Object.keys(entry)) {
+    if (entry[key] === null || entry[key] === undefined) delete entry[key];
+  }
+  if (Object.keys(entry).length) projects[dir] = entry;
+  else delete projects[dir];
+
+  return saveConfig({ projects: Object.keys(projects).length ? projects : null });
+}
+
 function muteRemainingText(state) {
   if (!state) return null;
   if (!state.until) return "indefinitely — until you run: vibe --unmute";
@@ -664,6 +756,11 @@ module.exports = {
   muteRemainingText,
   DEFAULT_MUTE_MINUTES,
   MUTE_FILE,
+  loadConfig,
+  saveConfig,
+  projectSettings,
+  saveProjectConfig,
+  CONFIG_FILE,
   CACHE_ROOT,
   CACHE_DIR
 };

package/src/synth/chiptune.js

@@ -64,16 +64,26 @@ function generateChiptuneLoop(durationSec = 7.5, tier = 2, seed = 0) {
     const startIdx = Math.floor(m.start * secPerBeat * SAMPLE_RATE);
     const numSamples = Math.floor(m.dur * secPerBeat * SAMPLE_RATE);
 
+    // Accumulated, for the same reason as the arpeggio below, plus one of its
+    // own: `softPulse((f + vib) * t)` is not vibrato but a phase that jumps
+    // when the vibrato switches on at t > 0.15 - by (vib * 0.15) cycles, once
+    // per note. Accumulating makes `vib` an actual frequency deviation of
+    // +/-3.5Hz, which is what it was meant to be, and the switch-on changes
+    // only the rate.
+    let leadPhase = 0.0;
+
     for (let i = 0; i < numSamples; i++) {
       const idx = startIdx + i;
       if (idx >= totalSamples) break;
       const t = i / SAMPLE_RATE;
       const env = Math.min(1.0, t * 75.0) * Math.max(0.0, 1.0 - (t / (m.dur * secPerBeat)));
       const vib = t > 0.15 ? Math.sin(2 * Math.PI * 5.5 * t) * 3.5 : 0.0;
-      const sample = softPulse((f + vib) * t) * env * 0.22;
+      const sample = softPulse(leadPhase) * env * 0.22;
 
       left[idx] += sample;
       right[idx] += sample;
+
+      leadPhase += (f + vib) / SAMPLE_RATE;
     }
   }
 
@@ -81,6 +91,22 @@ function generateChiptuneLoop(durationSec = 7.5, tier = 2, seed = 0) {
   const chords = variant.chords;
   const arpSpeed = 0.075;
 
+  // The phase is accumulated, not computed as `f * t`.
+  //
+  // This arpeggio steps to a new note every 75ms and has no envelope at all -
+  // it is meant to run continuously. With `softPulse(f * t)`, changing f while
+  // t keeps running jumps the phase by (f2 - f1) * t: hundreds of cycles a few
+  // seconds in, which lands the waveform on an arbitrary value. That is a
+  // click, 13 times a second, with no envelope to hide it - reported as static
+  // on 8bit, and at tier 1 every single step over 0.05 full-scale landed
+  // exactly on one of these boundaries.
+  //
+  // Accumulating instead means a new note changes the *rate* the phase
+  // advances, never its value, so the waveform stays continuous across the
+  // step. It is also how a real oscillator behaves.
+  let arpPhase = 0.0;
+  let shimmerPhase = 0.0;
+
   for (let i = 0; i < totalSamples; i++) {
     const t = i / SAMPLE_RATE;
     const beat = Math.floor(t / secPerBeat);
@@ -88,17 +114,20 @@ function generateChiptuneLoop(durationSec = 7.5, tier = 2, seed = 0) {
     const chord = chords[chordIdx];
     const noteIdx = Math.floor(t / arpSpeed) % chord.length;
     const f = noteToFreq(chord[noteIdx]);
-    const sample = softPulse(f * t) * (tier === 1 ? 0.09 : 0.075);
+    const sample = softPulse(arpPhase) * (tier === 1 ? 0.09 : 0.075);
 
     left[i] += sample * 0.85;
     right[i] += sample * 0.85;
 
     // Tier 3: octave-up shimmer arpeggio doubling
     if (tier >= 3) {
-      const shimmer = softPulse(f * 2.0 * t) * 0.03;
+      const shimmer = softPulse(shimmerPhase) * 0.03;
       left[i] += shimmer * 1.1;
       right[i] += shimmer * 0.9;
     }
+
+    arpPhase += f / SAMPLE_RATE;
+    shimmerPhase += (f * 2.0) / SAMPLE_RATE;
   }
 
   // 3. NES Triangle Bass

package/src/synth/electronic.js

@@ -13,6 +13,7 @@ const {
   makeRng,
   pick,
   ornamentRng,
+  pluckEnv,
   createWavBuffer
 } = require("./generator");
 
@@ -61,7 +62,7 @@ function generateElectronicLoop(durationSec = 6.4, tier = 2, seed = 0) {
       const tNote = t % stepSec;
       // Fast exponential decay filter simulation
       const filterCutoff = Math.exp(-tNote * 14.0);
-      const env = Math.exp(-tNote * 7.0);
+      const env = pluckEnv(tNote, stepSec, 7.0);
 
       // Resonant pluck wave: mixture of soft pulse and harmonics modulated by filter cutoff
       const osc = softPulse(f * t) * 0.7 + analogSaw(f * t) * 0.3 * filterCutoff;
@@ -87,7 +88,11 @@ function generateElectronicLoop(durationSec = 6.4, tier = 2, seed = 0) {
     const bar = Math.floor(t / (secPerBeat * 2.0)) % bassSeq.length;
     const f = noteToFreq(bassSeq[bar]);
     const tBeat = t % secPerBeat;
-    const env = Math.exp(-tBeat * 4.5);
+    // Same reason as the pluck above: a bare decay is 1.0 the instant tBeat
+    // wraps, which on a sub this deep is a thump rather than a note. It also
+    // lands the bar's pitch change on an envelope of zero, so the oscillator's
+    // phase jump there is inaudible.
+    const env = pluckEnv(tBeat, secPerBeat, 4.5);
 
     // Deep sine sub + triangle warmth
     const sub = (sine(f * t) * 0.75 + triangle(f * t) * 0.25) * env * 0.28;

package/src/synth/generator.js

@@ -114,6 +114,32 @@ function analogSaw(phase) {
  * Encodes audio buffers (Float Arrays in [-1.0, 1.0]) into a valid 16-bit PCM WAV Buffer.
  * Supports mono (single array) or stereo (array of [left, right] or { left: [], right: [] }).
  */
+/**
+ * A plucked note's amplitude envelope, and the reason it isn't a bare
+ * `Math.exp(-tNote * decay)`.
+ *
+ * A decay curve alone is 1.0 the instant `tNote` wraps back to zero, so every
+ * note onset steps the waveform discontinuously - in synthwave's bass, from
+ * 0.113 straight to 1.0, a jump of 0.13 full-scale in a single sample. That is
+ * a click, and at eighth notes it arrives 3.7 times a second: reported as
+ * "speaker static when the music intensifies", because the layers that use it
+ * only exist from tier 2 up.
+ *
+ * Ramping the attack from zero and forcing the release back to zero makes the
+ * envelope continuous at both ends of every note. It also covers the other
+ * discontinuity in the same voices: an arpeggiator changes `f` while `t` keeps
+ * running, so the oscillator's phase jumps at each new note - inaudible only
+ * because the envelope is at zero when it happens.
+ *
+ * 3ms and 4ms are short enough to leave a pluck percussive; chiptune.js has
+ * always done this (a 25ms ramp), which is why it never clicked.
+ */
+function pluckEnv(tNote, stepSec, decay, attackSec = 0.003, releaseSec = 0.004) {
+  const attack = Math.min(1.0, tNote / attackSec);
+  const release = Math.min(1.0, Math.max(0.0, (stepSec - tNote) / releaseSec));
+  return Math.exp(-tNote * decay) * attack * release;
+}
+
 function createWavBuffer({ left, right = null, sampleRate = SAMPLE_RATE }) {
   const isStereo = right != null && right.length > 0;
   const numChannels = isStereo ? 2 : 1;
@@ -175,5 +201,6 @@ module.exports = {
   triangle,
   softPulse,
   analogSaw,
+  pluckEnv,
   createWavBuffer
 };

package/src/synth/synthwave.js

@@ -10,6 +10,7 @@ const {
   triangle,
   makeRng,
   pick,
+  pluckEnv,
   createWavBuffer
 } = require("./generator");
 
@@ -98,7 +99,7 @@ function generateSynthwaveLoop(durationSec = 6.8, tier = 2, seed = 0) {
       if (idx >= totalSamples) break;
       const t = i / SAMPLE_RATE;
       const tNote = t % stepSec;
-      const env = Math.exp(-tNote * 8.0);
+      const env = pluckEnv(tNote, stepSec, 8.0);
       const sample = (triangle(f * t) * 0.7 + analogSaw(f * t) * 0.3) * env * 0.20;
 
       left[idx] += sample;
@@ -119,7 +120,7 @@ function generateSynthwaveLoop(durationSec = 6.8, tier = 2, seed = 0) {
       const noteIdx = Math.floor(t / stepSec) % leadNotes.length;
       const f = noteToFreq(leadNotes[noteIdx]);
       const tNote = t % stepSec;
-      const env = Math.exp(-tNote * 6.5);
+      const env = pluckEnv(tNote, stepSec, 6.5);
       const sample = analogSaw(f * t) * env * 0.085;
 
       const pan = 0.5 + 0.35 * Math.sin(2 * Math.PI * 1.5 * t);