opennote-cli 1.3.0

package/src/instrument.ts

@@ -0,0 +1,51 @@
+import type { GeneratedNote } from './types';
+
+export type InstrumentName = 'lead' | 'bass' | 'pad' | 'keys' | 'drums';
+
+export type InstrumentProfile = {
+  name: InstrumentName;
+  label: string;
+  midiChannel: number; // 0-15
+  program: number; // 0-127
+};
+
+const DRUM_NOTES = [36, 38, 42, 46, 41, 43, 49, 51];
+
+function clamp(n: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, n));
+}
+
+export function getInstrumentProfile(name: InstrumentName): InstrumentProfile {
+  if (name === 'bass') return { name, label: 'Bass', midiChannel: 0, program: 38 };
+  if (name === 'pad') return { name, label: 'Pad', midiChannel: 0, program: 88 };
+  if (name === 'keys') return { name, label: 'Keys', midiChannel: 0, program: 4 };
+  if (name === 'drums') return { name, label: 'Drums', midiChannel: 9, program: 0 };
+  return { name: 'lead', label: 'Lead', midiChannel: 0, program: 80 };
+}
+
+export function applyInstrumentProfile(
+  sequence: GeneratedNote[],
+  instrument: InstrumentName,
+): GeneratedNote[] {
+  if (instrument === 'drums') {
+    return sequence.map((note) => {
+      const idx = Math.abs(Math.round(note.pitch)) % DRUM_NOTES.length;
+      return {
+        pitch: DRUM_NOTES[idx],
+        velocity: clamp(note.velocity, 1, 127),
+        durationMs: clamp(note.durationMs, 40, 400),
+      };
+    });
+  }
+
+  const shift = instrument === 'bass' ? -24 : instrument === 'pad' ? -12 : instrument === 'keys' ? 0 : 12;
+  const min = instrument === 'bass' ? 28 : instrument === 'pad' ? 36 : instrument === 'keys' ? 48 : 60;
+  const max = instrument === 'bass' ? 60 : instrument === 'pad' ? 84 : instrument === 'keys' ? 92 : 108;
+
+  return sequence.map((note) => ({
+    pitch: clamp(note.pitch + shift, min, max),
+    velocity: clamp(note.velocity, 1, 127),
+    durationMs: clamp(note.durationMs, 40, 4000),
+  }));
+}
+

package/src/midi.js

@@ -0,0 +1,167 @@
+import readline from 'node:readline';
+import { createInterface } from 'node:readline/promises';
+const SCALE_OFFSETS = [0, 2, 4, 5, 7, 9, 11, 12];
+const SHIFT_MAP = {
+    '!': 1,
+    '@': 2,
+    '#': 3,
+    '$': 4,
+    '%': 5,
+    '^': 6,
+    '&': 7,
+    '*': 8,
+};
+const NOTE_NAMES = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
+const c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+};
+function fgHex(hex) {
+    const clean = hex.replace('#', '');
+    const r = Number.parseInt(clean.slice(0, 2), 16);
+    const g = Number.parseInt(clean.slice(2, 4), 16);
+    const b = Number.parseInt(clean.slice(4, 6), 16);
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+const palette = {
+    primary: fgHex('#d199ff'),
+    soft: fgHex('#ecebff'),
+};
+function color(text, code) {
+    return `${code}${text}${c.reset}`;
+}
+function pitchToName(pitch) {
+    const octave = Math.floor(pitch / 12) - 1;
+    return `${NOTE_NAMES[pitch % 12]}${octave}`;
+}
+function numberToPitch(numberKey, octave, sharp) {
+    const base = 12 * (octave + 1) + SCALE_OFFSETS[numberKey - 1];
+    return Math.max(0, Math.min(127, base + (sharp ? 1 : 0)));
+}
+async function lineFallbackSeed(baseOctave) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const raw = await rl.question('Seed key fallback (1-8, or !@#$%^&* for sharps, +/- octave not supported here): ');
+        const str = raw.trim();
+        const fromShiftSymbol = SHIFT_MAP[str];
+        const fromDigit = /^[1-8]$/.test(str) ? Number.parseInt(str, 10) : NaN;
+        const degree = Number.isFinite(fromShiftSymbol)
+            ? fromShiftSymbol
+            : Number.isFinite(fromDigit)
+                ? fromDigit
+                : 1;
+        const sharp = Boolean(fromShiftSymbol);
+        const pitch = numberToPitch(degree, baseOctave, sharp);
+        console.log(`Selected seed: ${pitchToName(pitch)} (${pitch})`);
+        return { pitch, velocity: 100 };
+    }
+    finally {
+        rl.close();
+    }
+}
+// Test-mode keyboard input:
+// 1-8 = scale degrees, Shift+1-8 = sharps, +/- changes octave.
+export async function waitForSeedNote(options = {}) {
+    let octave = options.baseOctave ?? 4;
+    console.log(`\n${color('Keyboard seed mode', `${c.bold}${palette.primary}`)}`);
+    console.log(color('Press 1-8 to choose note, Shift+1-8 for sharp, +/- for octave, q to cancel.', palette.soft));
+    console.log(color('Click this terminal window first if key presses are not detected.', `${c.bold}${palette.primary}`));
+    console.log(color(`Current octave: ${octave}`, palette.soft));
+    readline.emitKeypressEvents(process.stdin);
+    if (!process.stdin.isTTY) {
+        return lineFallbackSeed(octave);
+    }
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            process.stdin.off('keypress', onKeypress);
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+        };
+        const onKeypress = (str, key) => {
+            if (key.ctrl && key.name === 'c') {
+                cleanup();
+                reject(new Error('Seed note selection cancelled.'));
+                return;
+            }
+            if (str === '+' || str === '=') {
+                octave = Math.min(8, octave + 1);
+                console.log(color(`Octave: ${octave}`, palette.soft));
+                return;
+            }
+            if (str === '-') {
+                octave = Math.max(0, octave - 1);
+                console.log(color(`Octave: ${octave}`, palette.soft));
+                return;
+            }
+            if (key.name === 'q' || key.name === 'escape') {
+                cleanup();
+                reject(new Error('Seed note selection cancelled.'));
+                return;
+            }
+            const fromShiftSymbol = SHIFT_MAP[str];
+            const fromKeyName = key.name && /^[1-8]$/.test(key.name) ? Number.parseInt(key.name, 10) : NaN;
+            const degree = Number.isFinite(fromShiftSymbol)
+                ? fromShiftSymbol
+                : Number.isFinite(fromKeyName)
+                    ? fromKeyName
+                    : NaN;
+            if (!Number.isFinite(degree))
+                return;
+            const sharp = Boolean(fromShiftSymbol) || Boolean(key.shift);
+            const pitch = numberToPitch(degree, octave, sharp);
+            const noteName = pitchToName(pitch);
+            console.log(color(`Selected seed: ${noteName} (${pitch})`, palette.primary));
+            cleanup();
+            resolve({ pitch, velocity: 100 });
+        };
+        process.stdin.on('keypress', onKeypress);
+    });
+}
+// Replace with real MIDI output to your selected synth/device.
+export async function playSequenceToOutput(sequence, options = {}) {
+    const events = sequence[0]?.startMs != null
+        ? sequence
+        : (() => {
+            const out = [];
+            let t = 0;
+            for (const n of sequence) {
+                out.push({ pitch: n.pitch, velocity: n.velocity, durationMs: n.durationMs, startMs: t, channel: 0 });
+                t += n.durationMs;
+            }
+            return out;
+        })();
+    events.sort((a, b) => a.startMs - b.startMs);
+    if (options.instrument) {
+        console.log(color(`MIDI PROGRAM_CHANGE ch=${options.instrument.midiChannel + 1} program=${options.instrument.program} (${options.instrument.label})`, `${c.bold}${palette.primary}`));
+    }
+    const beatMs = 60000 / Math.max(1, options.bpm ?? 120);
+    if (options.metronome === 'count-in' || options.metronome === 'always') {
+        for (let i = 0; i < 4; i++) {
+            console.log(color(`METRONOME ${i + 1}`, palette.soft));
+            if (options.beep)
+                process.stdout.write('\x07');
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((r) => setTimeout(r, beatMs));
+        }
+    }
+    let prevStart = 0;
+    for (const note of events) {
+        const wait = Math.max(0, note.startMs - prevStart);
+        if (wait > 0) {
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((r) => setTimeout(r, wait));
+        }
+        console.log(color(`MIDI OUT NOTE_ON ${note.pitch} ${note.velocity}`, palette.primary));
+        if (options.beep)
+            process.stdout.write('\x07');
+        if (options.metronome === 'always' && note.startMs % Math.max(1, Math.round(beatMs)) < 24) {
+            console.log(color('METRONOME', palette.soft));
+        }
+        // eslint-disable-next-line no-await-in-loop
+        await new Promise((r) => setTimeout(r, note.durationMs));
+        console.log(color(`MIDI OUT NOTE_OFF ${note.pitch}`, palette.primary));
+        prevStart = note.startMs;
+    }
+}

package/src/midi.ts

@@ -0,0 +1,218 @@
+import readline from 'node:readline';
+import { createInterface } from 'node:readline/promises';
+import type { MetronomeMode, NoteEvent } from './arrangement';
+import type { InstrumentProfile } from './instrument';
+import type { GeneratedNote } from './types';
+
+export type MidiNoteOn = {
+  pitch: number;
+  velocity: number;
+};
+
+type SeedOptions = {
+  baseOctave?: number;
+};
+
+type PlaybackOptions = {
+  beep?: boolean;
+  instrument?: InstrumentProfile;
+  metronome?: MetronomeMode;
+  bpm?: number;
+};
+
+const SCALE_OFFSETS = [0, 2, 4, 5, 7, 9, 11, 12];
+const SHIFT_MAP: Record<string, number> = {
+  '!': 1,
+  '@': 2,
+  '#': 3,
+  '$': 4,
+  '%': 5,
+  '^': 6,
+  '&': 7,
+  '*': 8,
+};
+const NOTE_NAMES = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
+
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+};
+
+function fgHex(hex: string): string {
+  const clean = hex.replace('#', '');
+  const r = Number.parseInt(clean.slice(0, 2), 16);
+  const g = Number.parseInt(clean.slice(2, 4), 16);
+  const b = Number.parseInt(clean.slice(4, 6), 16);
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+const palette = {
+  primary: fgHex('#d199ff'),
+  soft: fgHex('#ecebff'),
+};
+
+function color(text: string, code: string): string {
+  return `${code}${text}${c.reset}`;
+}
+
+function pitchToName(pitch: number): string {
+  const octave = Math.floor(pitch / 12) - 1;
+  return `${NOTE_NAMES[pitch % 12]}${octave}`;
+}
+
+function numberToPitch(numberKey: number, octave: number, sharp: boolean): number {
+  const base = 12 * (octave + 1) + SCALE_OFFSETS[numberKey - 1];
+  return Math.max(0, Math.min(127, base + (sharp ? 1 : 0)));
+}
+
+async function lineFallbackSeed(baseOctave: number): Promise<MidiNoteOn> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const raw = await rl.question(
+      'Seed key fallback (1-8, or !@#$%^&* for sharps, +/- octave not supported here): ',
+    );
+    const str = raw.trim();
+    const fromShiftSymbol = SHIFT_MAP[str];
+    const fromDigit = /^[1-8]$/.test(str) ? Number.parseInt(str, 10) : NaN;
+    const degree = Number.isFinite(fromShiftSymbol)
+      ? fromShiftSymbol
+      : Number.isFinite(fromDigit)
+        ? fromDigit
+        : 1;
+    const sharp = Boolean(fromShiftSymbol);
+    const pitch = numberToPitch(degree, baseOctave, sharp);
+    console.log(`Selected seed: ${pitchToName(pitch)} (${pitch})`);
+    return { pitch, velocity: 100 };
+  } finally {
+    rl.close();
+  }
+}
+
+// Test-mode keyboard input:
+// 1-8 = scale degrees, Shift+1-8 = sharps, +/- changes octave.
+export async function waitForSeedNote(options: SeedOptions = {}): Promise<MidiNoteOn> {
+  let octave = options.baseOctave ?? 4;
+
+  console.log(`\n${color('Keyboard seed mode', `${c.bold}${palette.primary}`)}`);
+  console.log(color('Press 1-8 to choose note, Shift+1-8 for sharp, +/- for octave, q to cancel.', palette.soft));
+  console.log(color('Click this terminal window first if key presses are not detected.', `${c.bold}${palette.primary}`));
+  console.log(color(`Current octave: ${octave}`, palette.soft));
+
+  readline.emitKeypressEvents(process.stdin);
+  if (!process.stdin.isTTY) {
+    return lineFallbackSeed(octave);
+  }
+
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+
+  return new Promise<MidiNoteOn>((resolve, reject) => {
+    const cleanup = () => {
+      process.stdin.off('keypress', onKeypress);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    };
+
+    const onKeypress = (str: string, key: { name?: string; shift?: boolean; ctrl?: boolean }) => {
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        reject(new Error('Seed note selection cancelled.'));
+        return;
+      }
+
+      if (str === '+' || str === '=') {
+        octave = Math.min(8, octave + 1);
+        console.log(color(`Octave: ${octave}`, palette.soft));
+        return;
+      }
+
+      if (str === '-') {
+        octave = Math.max(0, octave - 1);
+        console.log(color(`Octave: ${octave}`, palette.soft));
+        return;
+      }
+
+      if (key.name === 'q' || key.name === 'escape') {
+        cleanup();
+        reject(new Error('Seed note selection cancelled.'));
+        return;
+      }
+
+      const fromShiftSymbol = SHIFT_MAP[str];
+      const fromKeyName = key.name && /^[1-8]$/.test(key.name) ? Number.parseInt(key.name, 10) : NaN;
+      const degree = Number.isFinite(fromShiftSymbol)
+        ? fromShiftSymbol
+        : Number.isFinite(fromKeyName)
+          ? fromKeyName
+          : NaN;
+
+      if (!Number.isFinite(degree)) return;
+
+      const sharp = Boolean(fromShiftSymbol) || Boolean(key.shift);
+      const pitch = numberToPitch(degree, octave, sharp);
+      const noteName = pitchToName(pitch);
+      console.log(color(`Selected seed: ${noteName} (${pitch})`, palette.primary));
+      cleanup();
+      resolve({ pitch, velocity: 100 });
+    };
+
+    process.stdin.on('keypress', onKeypress);
+  });
+}
+
+// Replace with real MIDI output to your selected synth/device.
+export async function playSequenceToOutput(
+  sequence: GeneratedNote[] | NoteEvent[],
+  options: PlaybackOptions = {},
+): Promise<void> {
+  const events: NoteEvent[] = (sequence as NoteEvent[])[0]?.startMs != null
+    ? (sequence as NoteEvent[])
+    : (() => {
+        const out: NoteEvent[] = [];
+        let t = 0;
+        for (const n of sequence as GeneratedNote[]) {
+          out.push({ pitch: n.pitch, velocity: n.velocity, durationMs: n.durationMs, startMs: t, channel: 0 });
+          t += n.durationMs;
+        }
+        return out;
+      })();
+
+  events.sort((a, b) => a.startMs - b.startMs);
+
+  if (options.instrument) {
+    console.log(
+      color(
+        `MIDI PROGRAM_CHANGE ch=${options.instrument.midiChannel + 1} program=${options.instrument.program} (${options.instrument.label})`,
+        `${c.bold}${palette.primary}`,
+      ),
+    );
+  }
+
+  const beatMs = 60000 / Math.max(1, options.bpm ?? 120);
+  if (options.metronome === 'count-in' || options.metronome === 'always') {
+    for (let i = 0; i < 4; i++) {
+      console.log(color(`METRONOME ${i + 1}`, palette.soft));
+      if (options.beep) process.stdout.write('\x07');
+      // eslint-disable-next-line no-await-in-loop
+      await new Promise((r) => setTimeout(r, beatMs));
+    }
+  }
+
+  let prevStart = 0;
+  for (const note of events) {
+    const wait = Math.max(0, note.startMs - prevStart);
+    if (wait > 0) {
+      // eslint-disable-next-line no-await-in-loop
+      await new Promise((r) => setTimeout(r, wait));
+    }
+    console.log(color(`MIDI OUT NOTE_ON ${note.pitch} ${note.velocity}`, palette.primary));
+    if (options.beep) process.stdout.write('\x07');
+    if (options.metronome === 'always' && note.startMs % Math.max(1, Math.round(beatMs)) < 24) {
+      console.log(color('METRONOME', palette.soft));
+    }
+    // eslint-disable-next-line no-await-in-loop
+    await new Promise((r) => setTimeout(r, note.durationMs));
+    console.log(color(`MIDI OUT NOTE_OFF ${note.pitch}`, palette.primary));
+    prevStart = note.startMs;
+  }
+}

package/src/openExport.js

@@ -0,0 +1,22 @@
+import { spawn } from 'node:child_process';
+function runOpen(args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('open', args, { stdio: 'ignore' });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`open exited with code ${code ?? -1}`));
+        });
+    });
+}
+export async function openExportTarget(path, target) {
+    if (target === 'none')
+        return;
+    if (target === 'finder') {
+        await runOpen(['-R', path]);
+        return;
+    }
+    await runOpen(['-a', 'GarageBand', path]);
+}

package/src/openExport.ts

@@ -0,0 +1,24 @@
+import { spawn } from 'node:child_process';
+
+export type OpenAfterExport = 'none' | 'finder' | 'garageband';
+
+function runOpen(args: string[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn('open', args, { stdio: 'ignore' });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`open exited with code ${code ?? -1}`));
+    });
+  });
+}
+
+export async function openExportTarget(path: string, target: OpenAfterExport): Promise<void> {
+  if (target === 'none') return;
+  if (target === 'finder') {
+    await runOpen(['-R', path]);
+    return;
+  }
+  await runOpen(['-a', 'GarageBand', path]);
+}
+

package/src/prompt.js

@@ -0,0 +1,22 @@
+export function systemPrompt() {
+    return [
+        'You are a melody continuation engine for MIDI.',
+        'Return JSON only, no markdown, no prose.',
+        'JSON shape: {"pitch":number,"velocity":number,"durationMs":number}.',
+        'pitch must be integer 0..127, velocity integer 1..127, durationMs integer >= 1.',
+    ].join(' ');
+}
+export function userPrompt(input) {
+    return JSON.stringify({
+        instruction: 'Generate exactly one next MIDI note that musically continues the melody.',
+        theme: input.theme,
+        targetLength: input.targetLength,
+        bpm: input.bpm,
+        seedPitch: input.seedPitch,
+        history: input.history,
+        constraints: {
+            maxJumpSemitones: 7,
+            preferredPitchRange: [48, 84],
+        },
+    });
+}

package/src/prompt.ts

@@ -0,0 +1,25 @@
+import type { NextNoteRequest } from './types';
+
+export function systemPrompt(): string {
+  return [
+    'You are a melody continuation engine for MIDI.',
+    'Return JSON only, no markdown, no prose.',
+    'JSON shape: {"pitch":number,"velocity":number,"durationMs":number}.',
+    'pitch must be integer 0..127, velocity integer 1..127, durationMs integer >= 1.',
+  ].join(' ');
+}
+
+export function userPrompt(input: NextNoteRequest): string {
+  return JSON.stringify({
+    instruction: 'Generate exactly one next MIDI note that musically continues the melody.',
+    theme: input.theme,
+    targetLength: input.targetLength,
+    bpm: input.bpm,
+    seedPitch: input.seedPitch,
+    history: input.history,
+    constraints: {
+      maxJumpSemitones: 7,
+      preferredPitchRange: [48, 84],
+    },
+  });
+}

package/src/providers/auth.js

@@ -0,0 +1,23 @@
+export function normalizeApiKey(raw) {
+    let key = raw.trim();
+    if (key.toLowerCase().startsWith('bearer ')) {
+        key = key.slice(7).trim();
+    }
+    return key;
+}
+export function assertHeaderSafeApiKey(provider, raw) {
+    const key = normalizeApiKey(raw);
+    if (!key) {
+        throw new Error(`${provider} API key is empty.`);
+    }
+    // HTTP header values must be ByteString-safe; reject non-Latin-1 characters.
+    const badIndex = [...key].findIndex((ch) => ch.codePointAt(0) > 255);
+    if (badIndex >= 0) {
+        const bad = [...key][badIndex];
+        throw new Error(`${provider} API key contains invalid character "${bad}". Re-enter key without extra symbols.`);
+    }
+    if (/\s/.test(key)) {
+        throw new Error(`${provider} API key contains whitespace. Re-enter key.`);
+    }
+    return key;
+}

package/src/providers/auth.ts

@@ -0,0 +1,30 @@
+export function normalizeApiKey(raw: string): string {
+  let key = raw.trim();
+  if (key.toLowerCase().startsWith('bearer ')) {
+    key = key.slice(7).trim();
+  }
+  return key;
+}
+
+export function assertHeaderSafeApiKey(provider: string, raw: string): string {
+  const key = normalizeApiKey(raw);
+  if (!key) {
+    throw new Error(`${provider} API key is empty.`);
+  }
+
+  // HTTP header values must be ByteString-safe; reject non-Latin-1 characters.
+  const badIndex = [...key].findIndex((ch) => ch.codePointAt(0)! > 255);
+  if (badIndex >= 0) {
+    const bad = [...key][badIndex];
+    throw new Error(
+      `${provider} API key contains invalid character "${bad}". Re-enter key without extra symbols.`,
+    );
+  }
+
+  if (/\s/.test(key)) {
+    throw new Error(`${provider} API key contains whitespace. Re-enter key.`);
+  }
+
+  return key;
+}
+

package/src/providers/claudeProvider.js

@@ -0,0 +1,46 @@
+import { systemPrompt, userPrompt } from '../prompt';
+import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
+export class ClaudeProvider {
+    apiKey;
+    model;
+    constructor(apiKey, model = 'claude-3-5-sonnet-latest') {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async nextNote(input) {
+        const maxRetries = 4;
+        for (let attempt = 0;; attempt++) {
+            const res = await fetch('https://api.anthropic.com/v1/messages', {
+                method: 'POST',
+                headers: {
+                    'x-api-key': this.apiKey,
+                    'anthropic-version': '2023-06-01',
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify({
+                    model: this.model,
+                    max_tokens: 120,
+                    system: systemPrompt(),
+                    messages: [
+                        { role: 'user', content: userPrompt(input) },
+                    ],
+                }),
+            });
+            if (!res.ok) {
+                const text = await res.text();
+                if (attempt < maxRetries && shouldRetryStatus(res.status)) {
+                    const delayMs = computeRetryDelayMs(res.headers.get('retry-after'), text, attempt);
+                    await waitForRetry(delayMs);
+                    continue;
+                }
+                throw new Error(`Claude request failed: ${res.status} ${text}`);
+            }
+            const json = await res.json();
+            const text = json.content?.find((item) => item.type === 'text')?.text;
+            if (!text) {
+                throw new Error('Claude response missing text content');
+            }
+            return JSON.parse(text);
+        }
+    }
+}

package/src/providers/claudeProvider.ts

@@ -0,0 +1,50 @@
+import type { GeneratedNote, LLMProvider, NextNoteRequest } from '../types';
+import { systemPrompt, userPrompt } from '../prompt';
+import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
+
+export class ClaudeProvider implements LLMProvider {
+  constructor(
+    private readonly apiKey: string,
+    private readonly model = 'claude-3-5-sonnet-latest',
+  ) {}
+
+  async nextNote(input: NextNoteRequest): Promise<GeneratedNote> {
+    const maxRetries = 4;
+    for (let attempt = 0; ; attempt++) {
+      const res = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+          'x-api-key': this.apiKey,
+          'anthropic-version': '2023-06-01',
+          'content-type': 'application/json',
+        },
+        body: JSON.stringify({
+          model: this.model,
+          max_tokens: 120,
+          system: systemPrompt(),
+          messages: [
+            { role: 'user', content: userPrompt(input) },
+          ],
+        }),
+      });
+
+      if (!res.ok) {
+        const text = await res.text();
+        if (attempt < maxRetries && shouldRetryStatus(res.status)) {
+          const delayMs = computeRetryDelayMs(res.headers.get('retry-after'), text, attempt);
+          await waitForRetry(delayMs);
+          continue;
+        }
+        throw new Error(`Claude request failed: ${res.status} ${text}`);
+      }
+
+      const json = await res.json() as { content?: Array<{ type?: string; text?: string }> };
+      const text = json.content?.find((item) => item.type === 'text')?.text;
+      if (!text) {
+        throw new Error('Claude response missing text content');
+      }
+
+      return JSON.parse(text) as GeneratedNote;
+    }
+  }
+}