all systems functional

Author: caged

src/frets/system/caged.js

@@ -24,9 +24,8 @@ export default function caged(strings, scale) {
 
   scale.notes.forEach((noteName, index) => {
     const noteObj = Note.get(noteName);
-    // For diatonic (7 notes): degrees are 1-7
-    // For pentatonic (5 notes): degrees are 0-4 (0-indexed as in the patterns)
-    const degree = noteCount === 7 ? index + 1 : index;
+    // Scale degrees are 1-indexed (1-5 for pentatonic, 1-7 for diatonic)
+    const degree = index + 1;
     chromaToScaleDegree.set(noteObj.chroma, degree);
     chromaToInterval.set(noteObj.chroma, scale.intervals[index]);
   });

src/frets/system/caged.test.js

@@ -1,25 +1,148 @@
 import { describe, expect, it } from "vitest";
 import { Scale } from "tonal";
 import frets from "../index.js";
+import caged from "./caged.js";
 
 describe("CAGED system", () => {
-  it("assigns G shape (position 5) correctly for C major", () => {
-    const scale = Scale.get("C major");
-    const fb = frets(["E2", "A2", "D3", "G3", "B3", "E4"], 16, scale);
-    const lowE = fb.strings[5]; // Low E string (reversed order)
+  describe("C major scale", () => {
+    it("assigns G shape (position 5) correctly - starts at fret 5 with A, B, C", () => {
+      const scale = Scale.get("C major");
+      const fb = frets(["E2", "A2", "D3", "G3", "B3", "E4"], 16, scale);
+      const lowE = fb.strings[5]; // Low E string (reversed order)
 
-    // G shape on low E string should have A (fret 5), B (fret 7), C (fret 8)
-    const aNote = lowE[5];
-    const bNote = lowE[7];
-    const cNote = lowE[8];
+      // G shape pattern on low E has degrees [6, 7, 1] = A, B, C
+      expect(lowE[5].note.pc).toBe("A");
+      expect(lowE[5].positions.CAGED).toContain(5);
 
-    expect(aNote.note.pc).toBe("A");
-    expect(aNote.positions.CAGED).toContain(5);
+      expect(lowE[7].note.pc).toBe("B");
+      expect(lowE[7].positions.CAGED).toContain(5);
 
-    expect(bNote.note.pc).toBe("B");
-    expect(bNote.positions.CAGED).toContain(5);
+      expect(lowE[8].note.pc).toBe("C");
+      expect(lowE[8].positions.CAGED).toContain(5);
+    });
 
-    expect(cNote.note.pc).toBe("C");
-    expect(cNote.positions.CAGED).toContain(5);
+    it("assigns E shape (position 1) correctly - starts at open position", () => {
+      const scale = Scale.get("C major");
+      const fb = frets(["E2", "A2", "D3", "G3", "B3", "E4"], 16, scale);
+      const lowE = fb.strings[5];
+
+      // E shape pattern on low E has degrees [7, 1, 2] = B, C, D
+      expect(lowE[7].note.pc).toBe("B");
+      expect(lowE[7].positions.CAGED).toContain(1);
+
+      expect(lowE[8].note.pc).toBe("C");
+      expect(lowE[8].positions.CAGED).toContain(1);
+
+      expect(lowE[10].note.pc).toBe("D");
+      expect(lowE[10].positions.CAGED).toContain(1);
+    });
+  });
+
+  describe("C minor scale", () => {
+    it("assigns G shape (position 5) correctly - starts at fret 8 with C, D, Eb", () => {
+      const scale = Scale.get("C minor");
+      const fb = frets(["E2", "A2", "D3", "G3", "B3", "E4"], 16, scale);
+      const lowE = fb.strings[5];
+
+      // For minor, G shape pattern rotates +2, so low E has degrees [1, 2, 3] = C, D, Eb
+      expect(lowE[8].note.pc).toBe("C");
+      expect(lowE[8].positions.CAGED).toContain(5);
+
+      expect(lowE[10].note.pc).toBe("D");
+      expect(lowE[10].positions.CAGED).toContain(5);
+
+      // Use label which reflects the scale's spelling (E♭ not D#)
+      expect(lowE[11].label).toBe("E♭");
+      expect(lowE[11].positions.CAGED).toContain(5);
+    });
+  });
+
+  describe("error handling", () => {
+    it("throws error for chromatic scale (12 notes)", () => {
+      const chromatic = Scale.get("C chromatic");
+      const fb = frets(["E2", "A2", "D3", "G3", "B3", "E4"], 16);
+      expect(() => caged(fb.strings, chromatic)).toThrow(
+        "CAGED system only works with 5-note pentatonic or 7-note scales"
+      );
+    });
+
+    it("throws error for 6-note scales", () => {
+      const blues = Scale.get("C blues");
+      const fb = frets(["E2", "A2", "D3", "G3", "B3", "E4"], 16);
+      expect(() => caged(fb.strings, blues)).toThrow(
+        "CAGED system only works with 5-note pentatonic or 7-note scales"
+      );
+    });
+  });
+
+  describe("position assignment", () => {
+    it("assigns positions to all scale notes", () => {
+      const scale = Scale.get("G major");
+      const fb = frets(["E2", "A2", "D3", "G3", "B3", "E4"], 16, scale);
+
+      for (const string of fb.strings) {
+        for (const note of string) {
+          if (note.interval) {
+            expect(note.positions.CAGED).toBeDefined();
+            expect(Array.isArray(note.positions.CAGED)).toBe(true);
+            expect(note.positions.CAGED.length).toBeGreaterThan(0);
+          }
+        }
+      }
+    });
+
+    it("assigns positions between 1 and 5", () => {
+      const scale = Scale.get("A minor");
+      const fb = frets(["E2", "A2", "D3", "G3", "B3", "E4"], 16, scale);
+
+      for (const string of fb.strings) {
+        for (const note of string) {
+          if (note.positions.CAGED?.length > 0) {
+            for (const pos of note.positions.CAGED) {
+              expect(pos).toBeGreaterThanOrEqual(1);
+              expect(pos).toBeLessThanOrEqual(5);
+            }
+          }
+        }
+      }
+    });
+
+    it("does not assign positions to non-scale notes", () => {
+      const scale = Scale.get("C major");
+      const fb = frets(["E2", "A2", "D3", "G3", "B3", "E4"], 16, scale);
+
+      for (const string of fb.strings) {
+        for (const note of string) {
+          if (!note.interval) {
+            expect(
+              note.positions.CAGED === undefined ||
+                note.positions.CAGED.length === 0
+            ).toBe(true);
+          }
+        }
+      }
+    });
+  });
+
+  describe("works with different keys", () => {
+    it("works with G major", () => {
+      const scale = Scale.get("G major");
+      const fb = frets(["E2", "A2", "D3", "G3", "B3", "E4"], 16, scale);
+      const lowE = fb.strings[5];
+
+      // G is at fret 3, should be in position 5 (G shape starts on root)
+      expect(lowE[3].note.pc).toBe("G");
+      expect(lowE[3].positions.CAGED).toContain(5);
+    });
+
+    it("works with E minor", () => {
+      const scale = Scale.get("E minor");
+      const fb = frets(["E2", "A2", "D3", "G3", "B3", "E4"], 16, scale);
+      const lowE = fb.strings[5];
+
+      // E is at fret 0 (open), should be in G shape (position 5) for minor
+      expect(lowE[0].note.pc).toBe("E");
+      expect(lowE[0].positions.CAGED).toContain(5);
+    });
   });
 });

src/frets/system/patterns.js

@@ -2,50 +2,50 @@
 // These patterns define which scale degrees appear on each string for each CAGED shape
 // Strings are in reversed order: [high E, B, G, D, A, low E]
 //
-// Scale degrees are indexed 0-4 for pentatonic (5 notes) or 0-6 for diatonic (7 notes)
+// Scale degrees are 1-5 for pentatonic or 1-7 for diatonic
 
 // Pentatonic patterns (2 notes per string)
 // Used by both Pentatonic and CAGED position systems for 5-note scales
 export const pentatonicPatterns = {
   C: [
-    [3, 4], // High E string: 5th, m7/6th
-    [1, 2], // B string: 2nd, 4th
-    [4, 0], // G string: m7/6th, root
-    [2, 3], // D string: 4th, 5th
-    [0, 1], // A string: root, 2nd
-    [3, 4], // Low E string: 5th, m7/6th
+    [4, 5], // High E string: 5th, m7/6th
+    [2, 3], // B string: 2nd, 4th
+    [5, 1], // G string: m7/6th, root
+    [3, 4], // D string: 4th, 5th
+    [1, 2], // A string: root, 2nd
+    [4, 5], // Low E string: 5th, m7/6th
   ],
   A: [
-    [4, 0], // High E string: m7/6th, root
-    [2, 3], // B string: 4th, 5th
-    [0, 1], // G string: root, 2nd
-    [3, 4], // D string: 5th, m7/6th
-    [1, 2], // A string: 2nd, 4th
-    [4, 0], // Low E string: m7/6th, root
+    [5, 1], // High E string: m7/6th, root
+    [3, 4], // B string: 4th, 5th
+    [1, 2], // G string: root, 2nd
+    [4, 5], // D string: 5th, m7/6th
+    [2, 3], // A string: 2nd, 4th
+    [5, 1], // Low E string: m7/6th, root
   ],
   G: [
-    [0, 1], // High E string: root, 2nd
-    [3, 4], // B string: 5th, m7/6th
-    [1, 2], // G string: 2nd, 4th
-    [4, 0], // D string: m7/6th, root
-    [2, 3], // A string: 4th, 5th
-    [0, 1], // Low E string: root, 2nd
+    [1, 2], // High E string: root, 2nd
+    [4, 5], // B string: 5th, m7/6th
+    [2, 3], // G string: 2nd, 4th
+    [5, 1], // D string: m7/6th, root
+    [3, 4], // A string: 4th, 5th
+    [1, 2], // Low E string: root, 2nd
   ],
   E: [
-    [1, 2], // High E string: 2nd, 4th
-    [4, 0], // B string: m7/6th, root
-    [2, 3], // G string: 4th, 5th
-    [0, 1], // D string: root, 2nd
-    [3, 4], // A string: 5th, m7/6th
-    [1, 2], // Low E string: 2nd, 4th
+    [2, 3], // High E string: 2nd, 4th
+    [5, 1], // B string: m7/6th, root
+    [3, 4], // G string: 4th, 5th
+    [1, 2], // D string: root, 2nd
+    [4, 5], // A string: 5th, m7/6th
+    [2, 3], // Low E string: 2nd, 4th
   ],
   D: [
-    [2, 3], // High E string: 4th, 5th
-    [0, 1], // B string: root, 2nd
-    [3, 4], // G string: 5th, m7/6th
-    [1, 2], // D string: 2nd, 4th
-    [4, 0], // A string: m7/6th, root
-    [2, 3], // Low E string: 4th, 5th
+    [3, 4], // High E string: 4th, 5th
+    [1, 2], // B string: root, 2nd
+    [4, 5], // G string: 5th, m7/6th
+    [2, 3], // D string: 2nd, 4th
+    [5, 1], // A string: m7/6th, root
+    [3, 4], // Low E string: 4th, 5th
   ],
 };
 
@@ -93,9 +93,8 @@ export const diatonicPatterns = {
   ],
 };
 
-// Position-to-shape mapping for CAGED and Pentatonic systems
+// Pentatonic box mapping for CAGED to Pentatonic boxes
 // Pentatonic: Position 1=G, 2=E, 3=D, 4=C, 5=A
-// CAGED: Position 1=C, 2=A, 3=G, 4=E, 5=D
 export const pentatonicPositionMapping = {
   1: "G",
   2: "E",

src/frets/system/pentatonic.js

@@ -33,18 +33,21 @@ export default function pentatonic(strings, scale) {
   // Major pentatonic: 1P 2M 3M 5P 6M
   const isMajor = intervals.includes("3M");
 
-  // For major pentatonic, we need to rotate the pattern indices
+  // For major pentatonic, we need to rotate the pattern degrees
   // This is because C major Position 1 should start at the 6th degree (A),
   // while C minor Position 1 starts at the root (C)
   // The offset is 4 positions forward (or 1 position backward) in the pentatonic scale
   const patternOffset = isMajor ? 4 : 0;
 
+  // Helper to rotate 1-indexed degrees (1-5)
+  const rotateDegree = (degree, offset) => ((degree - 1 + offset) % 5) + 1;
+
   const pentatonicShapes = Object.entries(pentatonicPositionMapping).map(
     ([pos, shape]) => {
       const basePattern = pentatonicPatterns[shape];
-      // Rotate the pattern indices for major scales
+      // Rotate the pattern degrees for major scales
       const rotatedPattern = basePattern.map((degreeArr) =>
-        degreeArr.map((degree) => (degree + patternOffset) % 5)
+        degreeArr.map((degree) => rotateDegree(degree, patternOffset))
       );
 
       return {
@@ -65,14 +68,16 @@ export default function pentatonic(strings, scale) {
 
       if (scaleNote) {
         const positions = [];
-        const scaleDegreeIndex = scaleNotes.findIndex(
-          (sn) => sn.note.chroma === semitone.note.chroma
-        );
+        // Scale degree is 1-indexed (1-5)
+        const scaleDegree =
+          scaleNotes.findIndex(
+            (sn) => sn.note.chroma === semitone.note.chroma
+          ) + 1;
 
         for (const shape of pentatonicShapes) {
           const stringPattern = shape.pattern[stringIndex];
 
-          if (stringPattern.includes(scaleDegreeIndex % 5)) {
+          if (stringPattern.includes(scaleDegree)) {
             positions.push(shape.position);
           }
         }