vibeaudio 0.6.1 → 0.6.3

package/README.md

@@ -23,6 +23,7 @@ AI coding agents take 15–45 seconds to reason, read files and write code. Star
 * 🧮 **Pure synthesis, zero MP3s.** Every note, chord and pad is generated in code — no audio assets, no npm dependencies, no `node-gyp`.
 * 🎼 **A different arrangement per project.** Your working directory seeds the progression, bass line and melody, so each repo has its own sound and keeps it.
 * 📈 **Escalating layers.** Tier 1 (0–15s) gentle intro → Tier 2 (15–45s) main groove → Tier 3 (45s+) deep focus. You can hear how deep into the task the agent is.
+* 🎛️ **Music that follows the work** ([reactive mode](#reactive-mode-opt-in), opt-in). Calm while the agent reads, fuller while it edits, busiest when it runs commands or hands work to sub-agents — you can hear *what* it's doing, not just for how long.
 * 🔔 **Outcome-aware chimes.** Ascending on success, a soft descending minor chord on failure, and **silence on `Ctrl+C`** — an abort is never reported as done.
 * ✋ **A "your turn" chime.** When Claude Code stops to ask permission (or an MCP server asks for input), the music pauses and a rising two-note chime asks for you; it picks back up once you've answered.
 * 🔌 **Universal drop-in.** Hooks for **Claude Code, Codex, Cursor, Grok, Gemini CLI, Copilot CLI and Qwen Code**; MCP for **Claude Desktop and Antigravity**; the wrapper (`vibe <command>`) for anything else.
@@ -94,6 +95,14 @@ That puts `vibe` and `vibeaudio` on your `PATH`. Re-run the same command to upda
 vibe --install-hooks
 ```
 
+Want the music to follow what the agent is doing — calm while it reads, busiest while it runs commands? Add `--reactive`:
+
+```bash
+vibe --reactive --install-hooks
+```
+
+Prefer a guided setup? Run `vibe` with nothing after it: a menu asks for your agent, genre and volume (press `p` to hear a genre first) and installs the hooks for you.
+
 Now run your agent normally, with no prefix. Music starts when you submit a prompt and stops with a chime when the agent finishes. [Details below.](#-agent-hooks-no-wrapper-needed)
 
 **Running one-shot commands?** Wrap them:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibeaudio",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Procedural focus music while your AI coding tools (Claude Code, Codex, Cursor, Grok, Gemini, Copilot) think \u2014 a different arrangement per project.",
   "bin": {
     "vibeaudio": "bin/vibeaudio.js",

package/scripts/postinstall.js

@@ -10,6 +10,21 @@
  * report and the user's to wonder about, so everything is wrapped and the exit
  * code is always 0 - a greeting is not worth a failed install.
  */
+// npm 7+ hides lifecycle-script stdout unless the script fails - measured on
+// npm 10, a global install printed only "added 1 package". The controlling
+// terminal is outside npm's pipe, so write there; stdout remains for when
+// there is no terminal (CI, Windows), where npm may or may not show it.
+function say(text) {
+  const fs = require("fs");
+  try {
+    const fd = fs.openSync("/dev/tty", "w");
+    fs.writeSync(fd, text + "\n");
+    fs.closeSync(fd);
+  } catch (e) {
+    console.log(text);
+  }
+}
+
 try {
   // Local installs are a dependency of something else; their user is not here
   // and not the one who would run `vibe`. CI and Docker set this too.
@@ -18,14 +33,16 @@ try {
   // install is already the narrow case - a dependency install sets this false.
   if (process.env.npm_config_global === "true") {
     const c = (code, text) => `\x1b[${code}m${text}\x1b[0m`;
-    console.log(`
-${c("1;36", "🎧 VibeAudio installed.")} Two ways to start:
+    say(`
+${c("1;36", "🎧 VibeAudio installed.")} Start here:
 
-  ${c("1", "vibe --install-hooks")}   ${c("90", "music follows your agent's thinking — best for Claude Code, Codex, Cursor…")}
-  ${c("1", "vibe npm test")}          ${c("90", "wrap any command that exits when it's done")}
+  ${c("1", "vibe")}                   ${c("90", "guided setup: pick your agent, genre and volume")}
+
+Or skip the menu:
 
-  ${c("90", "vibe            to pick a tool and a sound from a menu")}
-  ${c("90", "vibe --preview jazz   to hear one first")}
+  ${c("1", "vibe --install-hooks")}   ${c("90", "music follows your agent's thinking — Claude Code, Codex, Cursor…")}
+  ${c("1", "vibe npm test")}          ${c("90", "wrap any command that exits when it's done")}
+  ${c("1", "vibe --preview jazz")}    ${c("90", "hear a genre first")}
 `);
   }
 } catch (e) {

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