vibeaudio 0.4.0 → 0.6.1

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";
@@ -498,6 +590,7 @@ class AudioPlayer {
     this.volume = 0.42;
     this.seed = projectSeed();
     this.intensity = null;
+    this.minTier = null;
     this.currentTier = 1;
     this.nextTimer = null;
     this.watchdog = null;
@@ -507,7 +600,7 @@ class AudioPlayer {
    * Returns true if playback actually started. Restarts when called with
    * different settings while playing, so a genre switch is not silently dropped.
    */
-  start(genre = "lofi", volume = 0.42, { maxDurationMs = null, intensity = null } = {}) {
+  start(genre = "lofi", volume = 0.42, { maxDurationMs = null, intensity = null, minTier = null } = {}) {
     const resolved = resolveGenre(genre);
     const targetVolume = Math.max(0.05, Math.min(1.0, volume));
 
@@ -529,6 +622,7 @@ class AudioPlayer {
     this.volume = targetVolume;
     this.seed = projectSeed();
     this.intensity = intensity;
+    this.minTier = minTier;
 
     installExitHook();
     activePlayers.add(this);
@@ -560,7 +654,8 @@ class AudioPlayer {
     // An intensity source (reactive mode) overrides this when it has a signal.
     const elapsed = Date.now() - this.startTime;
     const byTime = elapsed > TIER_3_AFTER_MS ? 3 : elapsed > TIER_2_AFTER_MS ? 2 : 1;
-    this.currentTier = (this.intensity && this.intensity()) || byTime;
+    // A floor (several sessions at once) only ever raises the tier.
+    this.currentTier = Math.max((this.intensity && this.intensity()) || byTime, (this.minTier && this.minTier()) || 1);
 
     // Either the backend attenuates, or the file is rendered pre-attenuated -
     // never both, or the volume would be applied twice.
@@ -661,6 +756,11 @@ module.exports = {
   muteRemainingText,
   DEFAULT_MUTE_MINUTES,
   MUTE_FILE,
+  loadConfig,
+  saveConfig,
+  projectSettings,
+  saveProjectConfig,
+  CONFIG_FILE,
   CACHE_ROOT,
   CACHE_DIR
 };

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);