commitsmusic 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Meinianda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# 🎵 CommitsMusic
+
+Turn any git repository's history into **music**. One command, zero dependencies.
+
+```
+gitmuse ~/my-project
+```
+
+Each commit becomes a musical note. The melody is shaped by your commit patterns — late-night commits sound different from morning commits, big refactors hit harder than small fixes.
+
+## Install
+
+```bash
+npm install -g gitmuse-cli
+```
+
+Requires **Node.js >= 16**. That's it — no Python, no sound fonts, no external tools.
+
+## Usage
+
+```bash
+gitmuse                    # current directory
+gitmuse ~/my-project       # specific repo
+gitmuse --no-anim ~/repo   # audio only, skip animation
+```
+
+Set how many commits to use:
+
+```bash
+GITMUSE_MAX=100 gitmuse    # default: 200
+```
+
+## How it works
+
+```
+git log → key detection → commit→pitch mapping → Markov smoothing
+  → rhythmic phrasing (5 patterns) → piano synthesis
+  → accompaniment (strings, bass, harp, drums) → WAV → playback
+```
+
+**Commits control the pitch** — your commit hours directly map to notes
+**Algorithmic rhythm** — phrases are grouped by real time gaps, with swing and syncopation
+**Piano synthesis** — additive harmonics with ADSR envelope and hammer noise
+**Every note validated** — snapped to the detected key, no wrong notes
+
+## What you'll hear
+
+| Instrument | Role |
+|-----------|------|
+| Piano | Lead melody (from commits) |
+| Strings | Harmony + counter-melody |
+| Bass | Walking root-fifth pattern |
+| Harp | Arpeggiated chords |
+| Drums | Kick, snare, hi-hat, clap |
+
+## Try it by cloning this repo
+
+```
+git clone https://github.com/Meinianda-L/GitMuse
+```
+
+## License
+
+MIT

package/bin/commitsmusic.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+/** commitsmusic — git commit history → music */
+
+const fs=require('fs'),path=require('path');
+const{generate,writeWav}=require('../src/engine');
+const{playWithAnimation}=require('../src/animation');
+const{spawn}=require('child_process');
+
+// Terminal styling
+const CSI='\x1b[';
+const fg=c=>CSI+'38;5;'+c+'m';
+const dim=CSI+'2m';
+const bold=CSI+'1m';
+const reset=CSI+'0m';
+
+// ═══ Parse CLI args ══════════════════════════════════════════
+const args=process.argv.slice(2);
+
+let mode='direct';
+let repo='.';
+let nCommits=30;
+let animate=true;
+
+for(let i=0;i<args.length;i++){
+  const a=args[i];
+  if(a==='tui'){mode='tui';continue}
+  if(a==='-noan'||a==='--no-animation'){animate=false;continue}
+  if(a.startsWith('-')&&!isNaN(a.slice(1))){nCommits=parseInt(a.slice(1));continue}
+  if(!a.startsWith('-')){repo=a;continue}
+}
+
+// Resolve repo path
+repo=path.resolve(repo);
+
+if(mode==='tui'){
+  runTUI();
+}else{
+  runDirect(repo,nCommits,animate);
+}
+
+// ═══ Direct Mode ════════════════════════════════════════════
+async function runDirect(repo,n,anim){
+  try{
+    console.log(`\n  ${bold}commitsmusic${reset} — ${dim}${repo}${reset}\n`);
+    
+    const res=generate(repo,n);
+    const{key,totalTime,mel,acc,chordSeq,samples,commitNotes,cs}=res;
+    
+    console.log(`  Key: ${fg(220)}${key.name} ${key.mode}${reset}  |  ${cs.length}c → ${mel.length}n → ${Math.round(totalTime)}s`);
+    console.log(`  Chords: ${chordSeq.join(' → ')}`);
+    
+    // Write WAV
+    const wavPath=path.join(repo,'.commitsmusic.wav');
+    writeWav(samples,wavPath);
+    console.log(`  wav: ${dim}${wavPath}${reset}\n`);
+    
+    if(anim){
+      console.log('  Playing with animation... (q to quit)\n');
+      await new Promise(r=>setTimeout(r,500));
+      await playWithAnimation(samples,mel,commitNotes,totalTime,wavPath,key,cs.length);
+    }else{
+      console.log('  Playing...');
+      spawn('afplay',[wavPath],{stdio:'ignore'});
+      await new Promise(r=>setTimeout(r,totalTime*1000+500));
+    }
+    
+    // Ask to save
+    await askSave(wavPath);
+  }catch(e){
+    console.error(`  Error: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+// ═══ Save Prompt ════════════════════════════════════════════
+function askSave(wavPath){
+  return new Promise((resolve)=>{
+    const rl=require('readline').createInterface({input:process.stdin,output:process.stdout});
+    rl.question(`\n  Save audio? [y/N/path]: `,(ans)=>{
+      rl.close();
+      if(!ans||ans.toLowerCase()==='n'){
+        fs.unlinkSync(wavPath);
+        console.log('  Deleted.\n');
+      }else if(ans.toLowerCase()==='y'){
+        console.log(`  Saved: ${wavPath}\n`);
+      }else{
+        const dest=path.resolve(ans);
+        fs.copyFileSync(wavPath,dest);
+        fs.unlinkSync(wavPath);
+        console.log(`  Saved: ${dest}\n`);
+      }
+      resolve();
+    });
+  });
+}
+
+// ═══ TUI Mode ════════════════════════════════════════════════
+function runTUI(){
+  const{spawnSync}=require('child_process');
+  const tuiScript=path.join(__dirname,'..','src','tui.js');
+  const{status}=spawnSync(process.execPath,[tuiScript,...process.argv.slice(3)],{stdio:'inherit'});
+  process.exit(status||0);
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "commitsmusic",
+  "version": "1.0.0",
+  "description": "Turn git commit history into music with a beautiful TUI",
+  "main": "src/engine.js",
+  "bin": {
+    "commitsmusic": "./bin/commitsmusic.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "keywords": [
+    "git",
+    "music",
+    "tui",
+    "cli",
+    "visualization"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "blessed": "^0.1.81"
+  }
+}

package/src/animation.js

@@ -0,0 +1,205 @@
+/** commitsmusic — unbound timeline → smooth transition → piano roll */
+
+const { spawn } = require('child_process');
+
+const R='\x1b[0m',FG=c=>`\x1b[38;5;${c}m`,BG=c=>`\x1b[48;5;${c}m`;
+const B='\x1b[1m',D='\x1b[2m';
+const AS='\x1b[?1049h',AE='\x1b[?1049l',HI='\x1b[?25l',SH='\x1b[?25h';
+const HOME='\x1b[H',SB='\x1b[?2026h',SE='\x1b[?2026l';
+
+function noteColor(midi){
+  const t=(midi-38)/46;
+  const r=Math.floor(55+t*150),g=Math.floor(60+t*130),b=Math.floor(130-t*60);
+  return `\x1b[38;2;${Math.min(255,r)};${Math.min(255,g)};${Math.min(255,b)}m`;
+}
+
+function playWithAnimation(samples,melody,commitNotes,totalTime,wavPath,key,nCommits){
+  return new Promise(async resolve=>{
+
+    const allCommits=[],seen=new Set();
+    for(const n of melody.filter(x=>!x.tp)){
+      const id=n.msg+n.t;
+      if(!seen.has(id)){seen.add(id);allCommits.push(n)}
+    }
+    allCommits.sort((a,b)=>a.t-b.t);
+    const notes=allCommits.map(n=>({t:n.t,dur:n.dur,midi:n.midi,msg:n.msg||'',au:n.au||'?',files:n.files||[]}));
+
+    let player=null,quit=false;
+    process.stdout.write(AS+HI);
+    const wr=process.stdin.isRaw;
+    if(process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.on('data',d=>{if(d[0]===113||d[0]===3)quit=true});
+
+    const W=()=>process.stdout.columns||80,H=()=>process.stdout.rows||24;
+
+    // ═══ Timeline — scrolls freely, no cap ═══
+    const introTime=Math.min(5,totalTime*.35);
+    const per=Math.max(0.04,introTime/allCommits.length);
+    const tlX=Math.floor(W()*0.15);
+
+    for(let cursor=0;cursor<allCommits.length;cursor++){
+      if(quit){clean();resolve();return}
+      const w=W(),h=H();
+      const rows=[];
+
+      // Header
+      rows.push(center(`${B}${FG(220)}◈ commitsmusic${R}  ${D}git timeline${R}`,w));
+      rows.push(wfix(D+'╌'.repeat(w)+R,w));
+
+      // Show all commits from 0..cursor, newest at bottom, scroll up
+      const start=0; // NO cap — show everything
+      const count=cursor+1;
+      // Position: newest commit fixed near bottom, older ones scroll off top
+      const bottomPad=4; // rows reserved for progress bar
+      const firstVisibleRow=2; // after header+sep
+      const lastVisibleRow=h-bottomPad-1;
+      const avail=lastVisibleRow-firstVisibleRow+1;
+
+      // Each commit takes 2 rows (text + vertical line)
+      // Newest commit is at lastVisibleRow
+      // Scroll: as count grows, commits push up
+      const newestRow=lastVisibleRow-1; // commit at this row
+      const startRow=newestRow-(count-1)*2;
+
+      for(let i=0;i<count;i++){
+        const ci=start+i;
+        const c=allCommits[ci];
+        const isCurrent=ci===cursor;
+        const row=startRow+i*2;
+        
+        if(row<firstVisibleRow) continue; // scrolled off top
+        if(row>lastVisibleRow) continue;  // below viewport
+        
+        // Fill space before this row
+        while(rows.length<row) rows.push('');
+        
+        const age=(cursor-ci)/Math.max(1,cursor); // 0=newest, 1=oldest
+        const bright=Math.floor(248-age*80); // fade older commits
+        const dot=isCurrent?B+FG(220)+'●'+R:D+FG(bright)+'○'+R;
+        const msg=c.msg.slice(0,w-tlX-25);
+        const msgColor=isCurrent?FG(226):FG(bright);
+        
+        rows.push(`${wfix('',tlX)}${dot} ${D}${FG(240)}${isCurrent?'┣':'│'}${R} ${msgColor}${isCurrent?B:''}${msg}${R}`);
+        
+        // Vertical connector below (if not last)
+        if(i<count-1&&row+1<=lastVisibleRow){
+          while(rows.length<row+1) rows.push('');
+          rows.push(`${wfix('',tlX)}   ${D}${FG(240)}│${R}`);
+        }
+      }
+
+      // Fill to bottom
+      while(rows.length<h-3) rows.push('');
+
+      // Progress
+      const pct=(cursor+1)/allCommits.length;
+      const bw=Math.min(w-12,40);
+      const done=Math.floor(pct*bw);
+      rows.push(center(`${FG(220)}${'━'.repeat(done)}${FG(236)}${'─'.repeat(bw-done)}${R}`,w));
+      rows.push(center(`${D}${cursor+1}/${allCommits.length}${R}`,w));
+
+      process.stdout.write(SB+HOME+rows.join('\n')+'\x1b[J'+SE);
+      await sleep(per*1000);
+    }
+    if(quit){clean();resolve();return}
+
+    // ═══ Cinematic transition: flash → blackout → reveal ═══
+    // 1. Flash: all commit dots light up
+    {
+      const w=W(),h=H();
+      const rows=[];
+      rows.push(center(`${B}${FG(220)}◈ commitsmusic${R}  ${B}${FG(226)}${allCommits.length} commits loaded${R}`,w));
+      rows.push(wfix(D+'╌'.repeat(w)+R,w));
+      const show=Math.min(allCommits.length,h-6);
+      for(let j=0;j<show;j++){
+        const c=allCommits[j];
+        rows.push(`${wfix('',tlX)}  ${FG(220)}●${R} ${FG(226)}${c.msg.slice(0,w-tlX-20)}${R}`);
+      }
+      while(rows.length<h-2) rows.push('');
+      rows.push(center(`${FG(220)}▶${R}`,w));
+      process.stdout.write(SB+HOME+rows.join('\n')+'\x1b[J'+SE);
+      await sleep(400);
+    }
+    // 2. Blackout
+    {
+      const w=W(),h=H();
+      process.stdout.write(SB+HOME+Array(h).fill(wfix('',w)).join('\n')+'\x1b[J'+SE);
+      await sleep(200);
+    }
+
+    // ═══ Piano Roll ═══
+    try{player=spawn('afplay',[wavPath],{stdio:'ignore'})}catch(_){}
+    const t0=Date.now();
+    let active=null;
+
+    const iv=setInterval(()=>{
+      if(quit){clean();resolve();clearInterval(iv);return}
+      const el=(Date.now()-t0)/1000;
+      if(el>totalTime+1.5){clean();resolve();clearInterval(iv);return}
+
+      const w=W(),h=H(),hitX=Math.floor(w*0.18);
+      const ROLL=Math.max(3,h-11),miLo=38,miHi=84,spc=2.2/(w-hitX-4);
+
+      for(const n of notes){if(n.t<=el)active=n;else break}
+
+      const rows=[];
+      rows.push(wfix(`${B}${FG(220)}◈ commitsmusic${R}  ${FG(226)}${key.name} ${key.mode}${R}  ${B}${nCommits}c${R}  ${Math.round(totalTime)}s`,w));
+      rows.push(wfix(D+'╌'.repeat(w)+R,w));
+
+      for(let r=0;r<ROLL;r++){
+        const midi=Math.round(miHi-r/(ROLL-1)*(miHi-miLo));
+        const isRoot=midi%12===0,isFifth=midi%12===7;
+        rows.push(isRoot?wfix(FG(238)+'·'+FG(234)+'·'.repeat(w-2)+R,w)
+          :isFifth?wfix(FG(234)+'·'.repeat(w)+R,w):wfix('',w));
+      }
+
+      for(const n of notes){
+        const dt=n.t-el;
+        let x=hitX+Math.round(dt/spc),dw=Math.max(1,Math.round(n.dur/spc));
+        if(x<hitX){dw-=(hitX-x);x=hitX}
+        if(x>=w||dw<1)continue;
+        const ww=Math.min(dw,w-x);
+        const r=Math.round((miHi-n.midi)/(miHi-miLo)*(ROLL-1));
+        if(r<0||r>=ROLL)continue;
+        const ri=2+r,raw=rows[ri].replace(/\x1b\[[^m]*m/g,'');
+        rows[ri]=wfix(raw.slice(0,x)+noteColor(n.midi)+'█'.repeat(ww)+R+raw.slice(x+ww),w);
+      }
+
+      for(let r=0;r<ROLL;r++){
+        const ri=2+r,raw=rows[ri].replace(/\x1b\[[^m]*m/g,'');
+        rows[ri]=wfix(raw.slice(0,hitX)+B+FG(15)+BG(236)+'║'+R+raw.slice(hitX+1),w);
+      }
+
+      rows.push(wfix(D+'╌'.repeat(w)+R,w));
+
+      for(let i=0;i<6;i++){
+        let t='';
+        if(active){
+          if(i===0) t=`  ${B}${FG(220)}${active.msg.slice(0,w-6)}`;
+          else if(i===1) t=`  ${FG(248)}${D}by ${active.au}`;
+          else if(i===2&&active.files&&active.files.length)
+            t=`  ${FG(242)}${active.files.slice(0,5).join(' · ').slice(0,w-6)}`;
+        }
+        rows.push(wfix(t+R,w));
+      }
+
+      const pct=Math.min(1,el/totalTime),bw=w-18,f=Math.floor(pct*bw);
+      const ti=`${pad2(Math.floor(el/60))}:${pad2(Math.floor(el%60))} / ${pad2(Math.floor(totalTime/60))}:${pad2(Math.floor(totalTime%60))}`;
+      rows.push(`  ${FG(220)}${'▐'.repeat(f)}${D}${'▬'.repeat(bw-f)}${R}  ${FG(248)}${ti}${R}`);
+
+      process.stdout.write(SB+HOME+rows.join('\n')+'\x1b[J'+SE);
+    },67);
+
+    function clean(){
+      clearInterval(iv);if(player)player.kill();
+      process.stdin.setRawMode(wr);process.stdout.write(SH+AE);
+    }
+  });
+}
+
+function wfix(s,W,ch=' '){const c=s.replace(/\x1b\[[^;]*m/g,'');return s+ch.repeat(Math.max(0,W-c.length))}
+function pad2(n){return String(n).padStart(2,'0')}
+function center(s,w){const c=s.replace(/\x1b\[[^;]*m/g,'');const p=Math.floor((w-c.length)/2);return ' '.repeat(Math.max(0,p))+s}
+function sleep(ms){return new Promise(r=>setTimeout(r,ms))}
+
+module.exports={playWithAnimation};

package/src/engine.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+/** commitsmusic engine — parse commits, generate music, render WAV */
+
+const { execSync } = require('child_process');
+const fs = require('fs'), path = require('path');
+const SR = 44100;
+
+const SIN = new Float32Array(4096);
+for(let i=0;i<4096;i++) SIN[i]=Math.sin(2*Math.PI*i/4096);
+const sin=ph=>SIN[Math.min(4095,Math.floor((((ph%1)+1)%1)*4096))];
+const m2f=m=>440*2**((m-69)/12);
+
+// ═══ Git Parse ════════════════════════════════════════════════
+function parse(repo, n=30){
+  if(!fs.existsSync(path.join(repo,'.git'))) throw new Error(`not a git repository: ${repo}`);
+  const out=execSync(`git -C "${repo}" log --no-merges --format='%aI|%an|%s' --stat -n ${n}`,{encoding:'utf8',maxBuffer:10e6});
+  const cs=[];let c=null;
+  for(const l of out.split('\n')){
+    if(/^\d{4}-\d{2}-\d{2}T/.test(l)){if(c)cs.push(c);const p=l.split('|');c={d:p[0],au:p[1]||'unknown',m:p.slice(2).join('|')||'',i:0,x:0,files:[],diff:[]}}
+    else if(c){
+      const mi=l.match(/(\d+) insertion/), md=l.match(/(\d+) deletion/);
+      if(mi)c.i=+mi[1];if(md)c.x=+md[1];
+      // File line from --stat: " src/file.js | 5 +++"
+      const fm=l.match(/^\s+(.+?)\s+\|\s+\d+/);
+      if(fm)c.files.push(fm[1].trim());
+      if(c.diff.length<3) c.diff.push(l.trim());
+    }
+  }
+  if(c)cs.push(c);return cs.reverse();
+}
+
+// ═══ Music Theory ═════════════════════════════════════════════
+const NM='C C# D Eb E F F# G Ab A Bb B'.split(' ');
+const PM=[0,2,4,7,9], Pm=[0,3,5,7,10];
+const KS_M=[6.35,2.23,3.48,2.33,4.38,4.09,2.52,5.19,2.39,3.66,2.29,2.88];
+const KS_m=[6.33,2.68,3.52,5.38,2.60,3.53,2.54,4.75,3.98,2.69,3.34,3.17];
+
+function detectKey(raw){
+  const d=new Float32Array(12);let t=0;
+  for(const n of raw){d[n.midi%12]+=n.w;t+=n.w}
+  for(let i=0;i<12;i++)d[i]/=t;
+  let bk=0,bc=-2,bm='major';
+  for(let k=0;k<12;k++){
+    for(const[m,ks]of[['major',KS_M],['minor',KS_m]]){
+      const p=ks.map((_,i)=>ks[(i-k+12)%12]);let n=0,d1=0,d2=0;
+      for(let i=0;i<12;i++){n+=(d[i]-1/12)*(p[i]-p.reduce((a,b)=>a+b)/12);d1+=(d[i]-1/12)**2;d2+=(p[i]-p.reduce((a,b)=>a+b)/12)**2}
+      const c=n/Math.sqrt(d1*d2);if(c>bc){bc=c;bk=k;bm=m}
+    }
+  }
+  return{ki:bk,mode:bm,name:NM[bk],pt:(bm==='major'?PM:Pm).map(d=>(bk+d)%12),corr:bc};
+}
+function snap(midi,pt){const pc=midi%12;let b=midi,bd=99;for(const p of pt){const d=Math.min(Math.abs(pc-p),12-Math.abs(pc-p));if(d<bd){bd=d;b=midi-pc+p}}return Math.max(40,Math.min(84,b))}
+
+// ═══ Melody ═══════════════════════════════════════════════════
+function buildMelody(cs,key){
+  const pt=key.pt, mc=Math.max(1,...cs.map(c=>c.i+c.x));
+  const raw=cs.map(c=>({midi:snap(48+Math.round((c.i+c.x)/mc*31),pt),h:new Date(c.d).getHours(),w:(c.i+c.x)/mc,msg:c.m.slice(0,80),au:c.au||'unknown',files:c.files||[],diff:c.diff}));
+
+  let ci=0;for(let i=0;i<raw.length;i++)if(raw[i].w>raw[ci].w)ci=i;
+
+  // Voice leading
+  for(let i=1;i<raw.length;i++){const g=raw[i].midi-raw[i-1].midi;if(Math.abs(g)>7)raw[i].midi=snap(raw[i-1].midi+(g>0?5:-5),pt)}
+  for(let i=2;i<raw.length;i++){const g1=raw[i-1].midi-raw[i-2].midi,g2=raw[i].midi-raw[i-1].midi;if(Math.abs(g1)>=4)raw[i].midi=snap(raw[i-1].midi+(-Math.sign(g1)||-1)*2,pt);else if(Math.abs(g2)>=4&&Math.abs(g1)>=4&&g1*g2>0)raw[i].midi=snap(raw[i-1].midi-(g2>0?2:-2),pt)}
+
+  // Climax approach
+  if(ci>3){
+    const climMidi=snap(raw[ci].midi+12,pt);
+    for(let s=1;s<=3;s++){raw.splice(ci,0,{midi:snap(climMidi-4*s,pt),h:raw[ci].h,w:.3,msg:'',diff:[],tp:true,tn:'approach'});ci++}
+  }
+
+  // Passing tones
+  const nts=[];
+  for(let i=0;i<raw.length;i++){
+    if(!raw[i].tp) nts.push({...raw[i],tp:false}); else nts.push({...raw[i],tp:true});
+    if(i<raw.length-1&&!raw[i].tp&&!raw[i+1].tp){
+      const g=raw[i+1].midi-raw[i].midi,ag=Math.abs(g);
+      if(ag>=3&&ag<=4) nts.push({midi:snap(Math.round((raw[i].midi+raw[i+1].midi)/2),pt),h:raw[i].h,w:.15,msg:'',diff:[],tp:true});
+      else if(ag>=5){const d=g>0?1:-1;nts.push({midi:snap(raw[i].midi+d*2,pt),h:raw[i].h,w:.12,msg:'',diff:[],tp:true});nts.push({midi:snap(raw[i].midi+d*4,pt),h:raw[i].h,w:.12,msg:'',diff:[],tp:true})}
+    }
+  }
+
+  // Phrases
+  const phs=[];let ph=[nts[0]];for(let i=1;i<nts.length;i++){if(Math.abs(nts[i].h-nts[i-1].h)>4&&ph.length>=3){phs.push(ph);ph=[]}ph.push(nts[i])}if(ph.length)phs.push(ph);
+
+  // Rhythm
+  const BPM=80,beat=60/BPM;
+  const durPatterns=[
+    [2,0.5,1,0.5, 2,0.5,1,1],
+    [1.5,0.5,1,1, 1.5,0.5,1,1],
+    [1,0.5,0.5,1, 2,0.5,0.5,1],
+    [2,1,0.5,0.5, 1.5,1,0.5,1],
+    [1,1,1,0.5, 2,0.5,1,0.5],
+  ];
+
+  const mel=[];let time=0;
+  for(let pi=0;pi<phs.length;pi++){
+    const phr=phs[pi], dp=durPatterns[pi%durPatterns.length];
+    let di=0;
+    for(let ni=0;ni<phr.length;ni++){
+      const n=phr[ni];
+      const durBeats=dp[di%dp.length];
+      let dur=beat*durBeats;
+      if(n.tp) dur=beat*0.5;
+      const vel=n.tp?.15:.55;
+      mel.push({freq:m2f(n.midi),midi:n.midi,t:Math.round(time*1e3)/1e3,dur:Math.round(dur*1e3)/1e3,vel,msg:n.msg,au:n.au||'unknown',files:n.files||[],diff:n.diff,tp:n.tp});
+      time+=dur;
+      if(!n.tp) di++;
+    }
+    time+=beat*0.5;
+  }
+
+  return{mel,totalTime:time,phs,ci,raw};
+}
+
+// ═══ Chords (SCFA) ════════════════════════════════════════════
+function buildAccompaniment(melody, totalTime, key){
+  const BPM=80,beat=60/BPM,bar=beat*4;
+  const pad=[], drums=[];
+  const cofDeg=[0,7,2,9,4,11,5,10,3,8,1,6];
+  const keyRoot=key.ki;
+  const allChords=[];
+  for(let ci=0;ci<12;ci++){
+    const root=(keyRoot+cofDeg[ci])%12;
+    const isMinor=[2,4,9].includes(cofDeg[ci]);
+    const third=(root+(isMinor?3:4))%12, fifth=(root+7)%12;
+    allChords.push({name:NM[root]+(isMinor?'m':''),root,third,fifth,cofPos:ci});
+  }
+  const symPositions=[0,3,6,9];
+  let t=0,lastCof=-1;
+  while(t<totalTime){
+    const sd=Math.min(bar*2,totalTime-t);
+    const melHere=melody.filter(n=>n.t>=t&&n.t<t+sd&&!n.tp);
+    const melPCs=new Set(melHere.map(n=>n.midi%12));
+    const melCount={};for(const pc of melPCs){melCount[pc]=melHere.filter(n=>n.midi%12===pc).length}
+    
+    let bestCh=null,bestScore=-1;
+    for(const pos of symPositions){
+      const ch=allChords[pos];
+      if(pos===lastCof) continue;
+      let score=0;
+      for(const ct of[ch.root,ch.third,ch.fifth]){
+        if(melPCs.has(ct)) score+=2+(melCount[ct]||0);
+        if(melPCs.has((ct+2)%12)) score+=1;
+      }
+      if(score>bestScore){bestScore=score;bestCh=ch}
+    }
+    if(!bestCh){for(const ch of allChords){if(ch.cofPos===lastCof)continue;let score=0;for(const ct of[ch.root,ch.third,ch.fifth])if(melPCs.has(ct))score+=2;if(score>bestScore){bestScore=score;bestCh=ch}}}
+    if(!bestCh) bestCh=allChords[0];
+    lastCof=bestCh.cofPos;
+
+    const{r:rt,t:tt,f:ft}=bestCh;
+    for(const m of[ft+36,rt+48,tt+48,ft+48,rt+60,tt+60]) pad.push({freq:m2f(m),t,dur:sd,vel:.12,chordName:bestCh.name});
+
+    const steps16=Math.floor(sd/(beat/4));
+    for(let s=0;s<steps16;s++){
+      const dt=Math.round((t+s*beat/4)*1e3)/1e3, p=s%16;
+      if(p===0||p===8) drums.push({type:'kick',t:dt,dur:.12,vel:.4});
+      if(p===14&&s%32<16) drums.push({type:'kick',t:dt,dur:.06,vel:.15});
+      if(p===4||p===12) drums.push({type:'snare',t:dt,dur:.07,vel:.28});
+      if(p%2===0) drums.push({type:'hat',t:dt,dur:.03,vel:.1});
+    }
+    t+=sd;
+  }
+  return{pad,drums};
+}
+
+// ═══ Synths ══════════════════════════════════════════════════
+function pianoS(freq,dur,vel,midi){
+  const fmComp=1+Math.max(0,(midi-50))*0.025;
+  const ts=Math.floor(Math.max(.02,dur)*SR),o=new Float32Array(ts);
+  for(const h of[{m:1,a:.8},{m:2,a:.5},{m:3,a:.25},{m:4,a:.12}]){
+    const f=freq*h.m*(1+h.m*.0002);
+    for(let i=0;i<ts;i++){const t=i/SR,e=t<.003?t/.003:(t<dur*.2?1-.65*(t-.003)/(dur*.2):(t<dur*.75?.35:.35*(1-(t-dur*.75)/(dur*.25))));o[i]+=sin(f*t)*h.a*e}
+  }
+  for(let i=0;i<Math.min(160,ts);i++)o[i]+=(Math.random()*2-1)*Math.exp(-i/150)*.05;
+  let rms=0;for(let i=0;i<ts;i++)rms+=o[i]*o[i];rms=Math.sqrt(rms/ts);
+  for(let i=0;i<ts;i++)o[i]*=(vel*fmComp)/(rms||1e-9);
+  return o;
+}
+function padS(freq,dur,vel){
+  const ts=Math.floor(dur*SR),o=new Float32Array(ts);
+  for(const h of[{m:1,a:.6},{m:2,a:.4},{m:3,a:.2}]){const f=freq*h.m;for(let i=0;i<ts;i++){const t=i/SR;o[i]+=sin(f*t)*h.a*Math.min(1,t*3)*Math.exp(-t*.15/dur)*vel}}
+  return o;
+}
+function kickS(d,v){const ts=Math.floor(d*SR),o=new Float32Array(ts);for(let i=0;i<ts;i++){const t=i/SR;o[i]=sin((55+130*Math.exp(-t*18))*t)*Math.exp(-t*8)*v}return o}
+function snareS(d,v){const ts=Math.floor(d*SR),o=new Float32Array(ts);for(let i=0;i<ts;i++){const t=i/SR;o[i]=((Math.random()*2-1)*Math.exp(-t*25)*.35+sin(200*t)*Math.exp(-t*12)*.2)*Math.exp(-t*5)*v}return o}
+function hatS(d,v){const ts=Math.floor(d*SR),o=new Float32Array(ts);for(let i=0;i<ts;i++)o[i]=(Math.random()*2-1)*Math.exp(-i/SR*70)*v*.2;return o}
+function mix(t,b,o){for(let i=0;i<b.length&&o+i<t.length;i++){t[o+i]+=b[i];if(t[o+i]>3)t[o+i]=3;if(t[o+i]<-3)t[o+i]=-3}}
+
+// ═══ Render ═══════════════════════════════════════════════════
+function renderAll(melody,acc,totalTime){
+  const TS=Math.floor(totalTime*SR*1.03),mx=new Float32Array(TS);
+  let climaxT=totalTime*.5, maxMidi=0;
+  for(const n of melody){if(!n.tp&&n.midi>maxMidi){maxMidi=n.midi;climaxT=n.t+n.dur*.5}}
+  for(const n of melody){
+    const buf=pianoS(n.freq,n.dur,n.vel,n.midi);
+    const distFromClimax=Math.abs(n.t-climaxT)/totalTime;
+    const dynArc=.55+.45*(1-Math.min(1,distFromClimax*2));
+    for(let i=0;i<buf.length;i++) buf[i]*=dynArc;
+    mix(mx, buf, Math.floor(n.t*SR));
+  }
+  for(const p of acc.pad) mix(mx, padS(p.freq,p.dur,p.vel), Math.floor(p.t*SR));
+  for(const d of acc.drums) mix(mx, d.type==='kick'?kickS(d.dur,d.vel):d.type==='snare'?snareS(d.dur,d.vel):hatS(d.dur,d.vel), Math.floor(d.t*SR));
+  for(let i=0;i<Math.floor(.08*SR)&&i<TS;i++)mx[i]*=i/(.08*SR);
+  for(let i=Math.max(0,TS-Math.floor(.12*SR));i<TS;i++)mx[i]*=(TS-i)/(.12*SR);
+  let pk=0;for(let i=0;i<TS;i++)pk=Math.max(pk,Math.abs(mx[i]));
+  if(pk>0){const ng=.9/pk;for(let i=0;i<TS;i++)mx[i]=Math.tanh(mx[i]*ng)}
+  return mx;
+}
+function writeWav(sp,fp){
+  const N=sp.length,b=Buffer.alloc(44+N*2);
+  b.write('RIFF',0);b.writeUInt32LE(36+N*2,4);b.write('WAVE',8);
+  b.write('fmt ',12);b.writeUInt32LE(16,16);b.writeUInt16LE(1,20);b.writeUInt16LE(1,22);
+  b.writeUInt32LE(SR,24);b.writeUInt32LE(SR*2,28);b.writeUInt16LE(2,32);b.writeUInt16LE(16,34);
+  b.write('data',36);b.writeUInt32LE(N*2,40);
+  for(let i=0;i<N;i++)b.writeInt16LE(Math.max(-32768,Math.min(32767,Math.floor(sp[i]*32767))),44+i*2);
+  fs.writeFileSync(fp,b);
+}
+
+// ═══ Generate Pipeline ════════════════════════════════════════
+function generate(repo, n=30){
+  const cs=parse(repo, n);
+  if(!cs.length) throw new Error('no commits found');
+  const mc=Math.max(1,...cs.map(c=>c.i+c.x));
+  const rawForKey=cs.map(c=>({midi:48+Math.round((c.i+c.x)/mc*31),w:(c.i+c.x)/mc}));
+  const key=detectKey(rawForKey);
+  const{mel,totalTime}=buildMelody(cs,key);
+  const acc=buildAccompaniment(mel,totalTime,key);
+  const samples=renderAll(mel,acc,totalTime);
+  const chordSeq=[...new Set(acc.pad.map(p=>p.chordName))];
+  
+  // Attach commit index to melody notes for animation
+  const commitNotes=mel.filter(n=>!n.tp);
+  
+  return{samples,totalTime,key,mel,acc,chordSeq,commitNotes,cs};
+}
+
+module.exports={generate,writeWav,SR};

package/src/tui.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/** commitsmusic TUI — blessed selector → engine → animation */
+
+const blessed=require('blessed');
+const fs=require('fs'),path=require('path');
+const{generate,writeWav}=require('./engine');
+const{playWithAnimation}=require('./animation');
+const{spawn}=require('child_process');
+
+// ═══ Find repos ═════════════════════════════════════════════
+function findRepos(){
+  const dirs=[];
+  function scan(dir,d=0){
+    if(d>3)return;
+    try{for(const e of fs.readdirSync(dir,{withFileTypes:true})){
+      if(e.name.startsWith('.'))continue;
+      const fp=path.join(dir,e.name);
+      if(e.isDirectory()){try{if(fs.existsSync(path.join(fp,'.git')))dirs.push(fp);else scan(fp,d+1)}catch(_){}}
+    }}catch(_){}
+  }
+  const home=process.env.HOME||'/Users/'+process.env.USER;
+  scan(home,1);scan(path.join(home,'Desktop'),2);
+  const cwd=process.cwd();
+  if(!dirs.includes(cwd)&&fs.existsSync(path.join(cwd,'.git')))dirs.unshift(cwd);
+  return dirs.length?dirs:[cwd];
+}
+
+const repos=findRepos();
+const state={repo:repos[0],nCommits:30,animate:true};
+
+function dim(s){return s.length>80?'...'+s.slice(-77):s}
+
+// ═══ Screen ═════════════════════════════════════════════════
+const screen=blessed.screen({smartCSR:true,title:'commitsmusic',fullUnicode:true});
+
+const header=blessed.box({
+  top:0,left:0,width:'100%',height:2,
+  content:'{bold}{yellow-fg}  ♪ commitsmusic{/yellow-fg}{/bold}  {grey-fg}turn git history into music{/grey-fg}',
+  tags:true,
+});
+
+const repoList=blessed.list({
+  top:3,left:2,width:'100%-4',height:Math.min(9,repos.length+2),
+  label:'{bold} Repository {/bold}',
+  items:repos.map(r=>path.basename(r)+'  '+dim(r)),
+  keys:true,vi:true,
+  style:{selected:{fg:'black',bg:'yellow'},item:{fg:'white',bg:'black'}},
+  border:{type:'line',fg:'cyan'},
+  tags:true,
+});
+repoList.on('select',(_,idx)=>{state.repo=repos[idx];updateInfo()});
+
+const infoBox=blessed.box({
+  top:13,left:2,width:'100%-4',height:4,shrink:true,
+  border:{type:'line',fg:'cyan'},
+  tags:true,
+});
+function updateInfo(){
+  const bar='█'.repeat(Math.min(state.nCommits/10,15))+'░'.repeat(Math.max(0,15-Math.floor(state.nCommits/10)));
+  infoBox.setContent(
+    `{bold}Commits:{/bold} {yellow-fg}${state.nCommits}{/yellow-fg}  ${bar}\n`+
+    `{bold}Animation:{/bold} ${state.animate?'{green-fg}ON{/green-fg}':'{red-fg}OFF{/red-fg}'}\n`+
+    `{cyan-fg}${dim(state.repo)}{/cyan-fg}`
+  );
+  screen.render();
+}
+updateInfo();
+
+const helpBox=blessed.box({
+  bottom:3,left:0,width:'100%',height:2,
+  content:'{grey-fg}  ↑↓ repo  ←→ commits  a toggle anim  Enter GENERATE  q quit{/grey-fg}',
+  tags:true,
+});
+
+const genBtn=blessed.box({
+  bottom:1,left:'center',width:24,height:1,
+  content:'{black-fg}{yellow-bg}  ▶  GENERATE  {/yellow-bg}{/black-fg}',
+  tags:true,align:'center',
+});
+
+screen.append(header);screen.append(repoList);screen.append(infoBox);
+screen.append(helpBox);screen.append(genBtn);
+
+screen.key(['left','h'],()=>{state.nCommits=Math.max(10,state.nCommits-10);updateInfo()});
+screen.key(['right','l'],()=>{state.nCommits=Math.min(500,state.nCommits+10);updateInfo()});
+screen.key(['a'],()=>{state.animate=!state.animate;updateInfo()});
+screen.key(['q','C-c'],()=>{screen.destroy();process.exit(0)});
+screen.key(['enter'],()=>runGenerate());
+
+screen.render();repoList.focus();
+
+// ═══ Generate & Play ════════════════════════════════════════
+async function runGenerate(){
+  screen.destroy();
+  try{
+    console.log(`\n  {bold}commitsmusic{/bold} — ${dim(state.repo)}\n`.replace(/\{(\/?)\w+(-\w+)?\}/g,''));
+    const res=generate(state.repo,state.nCommits);
+    const{key,totalTime,mel,chordSeq,samples,commitNotes,cs}=res;
+    console.log(`  Key: ${key.name} ${key.mode}  |  ${cs.length}c → ${mel.length}n → ${Math.round(totalTime)}s`);
+    console.log(`  Chords: ${chordSeq.join(' → ')}`);
+    const wavPath=path.join(state.repo,'.commitsmusic.wav');
+    writeWav(samples,wavPath);
+    console.log(`  wav: ${wavPath}\n`);
+
+    if(state.animate){
+      console.log('  Playing... (q to quit)\n');
+      await new Promise(r=>setTimeout(r,800));
+      await playWithAnimation(samples,mel,commitNotes,totalTime,wavPath,key,cs.length);
+    }else{
+      console.log('  Playing...');
+      spawn('afplay',[wavPath],{stdio:'ignore'});
+      await new Promise(r=>setTimeout(r,totalTime*1000+500));
+    }
+
+    // Save prompt
+    const rl=require('readline').createInterface({input:process.stdin,output:process.stdout});
+    rl.question('\n  Save audio? [y/N/path]: ',(a)=>{
+      rl.close();
+      if(!a||a.toLowerCase()==='n'){fs.unlinkSync(wavPath);console.log('  Deleted.')}
+      else if(a.toLowerCase()==='y'){console.log(`  Saved: ${wavPath}`)}
+      else{const d=path.resolve(a);fs.copyFileSync(wavPath,d);fs.unlinkSync(wavPath);console.log(`  Saved: ${d}`)}
+      process.exit(0);
+    });
+  }catch(e){
+    console.error(`  Error: ${e.message}`);
+    process.exit(1);
+  }
+}