opennote-cli 1.3.0

package/src/providers/factory.js

@@ -0,0 +1,39 @@
+import { ClaudeProvider } from './claudeProvider';
+import { GeminiProvider } from './geminiProvider';
+import { GrokProvider } from './grokProvider';
+import { GroqProvider } from './groqProvider';
+import { MockProvider } from './mockProvider';
+import { OpenAIProvider } from './openaiProvider';
+export function buildProvider(name) {
+    if (name === 'mock') {
+        return new MockProvider();
+    }
+    if (name === 'openai') {
+        const apiKey = process.env.OPENAI_API_KEY;
+        if (!apiKey)
+            throw new Error('Missing OPENAI_API_KEY');
+        return new OpenAIProvider(apiKey, process.env.OPENAI_MODEL || 'gpt-4.1-mini');
+    }
+    if (name === 'gemini') {
+        const apiKey = process.env.GEMINI_API_KEY;
+        if (!apiKey)
+            throw new Error('Missing GEMINI_API_KEY');
+        return new GeminiProvider(apiKey, process.env.GEMINI_MODEL || 'gemini-2.0-flash');
+    }
+    if (name === 'groq') {
+        const apiKey = process.env.GROQ_API_KEY;
+        if (!apiKey)
+            throw new Error('Missing GROQ_API_KEY');
+        return new GroqProvider(apiKey, process.env.GROQ_MODEL || 'llama-3.3-70b-versatile');
+    }
+    if (name === 'grok') {
+        const apiKey = process.env.XAI_API_KEY;
+        if (!apiKey)
+            throw new Error('Missing XAI_API_KEY');
+        return new GrokProvider(apiKey, process.env.GROK_MODEL || 'grok-2-latest');
+    }
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey)
+        throw new Error('Missing ANTHROPIC_API_KEY');
+    return new ClaudeProvider(apiKey, process.env.CLAUDE_MODEL || 'claude-3-5-sonnet-latest');
+}

package/src/providers/factory.ts

@@ -0,0 +1,43 @@
+import type { LLMProvider } from '../types';
+import { ClaudeProvider } from './claudeProvider';
+import { GeminiProvider } from './geminiProvider';
+import { GrokProvider } from './grokProvider';
+import { GroqProvider } from './groqProvider';
+import { MockProvider } from './mockProvider';
+import { OpenAIProvider } from './openaiProvider';
+
+export type ProviderName = 'mock' | 'openai' | 'gemini' | 'claude' | 'groq' | 'grok';
+
+export function buildProvider(name: ProviderName): LLMProvider {
+  if (name === 'mock') {
+    return new MockProvider();
+  }
+
+  if (name === 'openai') {
+    const apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) throw new Error('Missing OPENAI_API_KEY');
+    return new OpenAIProvider(apiKey, process.env.OPENAI_MODEL || 'gpt-4.1-mini');
+  }
+
+  if (name === 'gemini') {
+    const apiKey = process.env.GEMINI_API_KEY;
+    if (!apiKey) throw new Error('Missing GEMINI_API_KEY');
+    return new GeminiProvider(apiKey, process.env.GEMINI_MODEL || 'gemini-2.0-flash');
+  }
+
+  if (name === 'groq') {
+    const apiKey = process.env.GROQ_API_KEY;
+    if (!apiKey) throw new Error('Missing GROQ_API_KEY');
+    return new GroqProvider(apiKey, process.env.GROQ_MODEL || 'llama-3.3-70b-versatile');
+  }
+
+  if (name === 'grok') {
+    const apiKey = process.env.XAI_API_KEY;
+    if (!apiKey) throw new Error('Missing XAI_API_KEY');
+    return new GrokProvider(apiKey, process.env.GROK_MODEL || 'grok-2-latest');
+  }
+
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) throw new Error('Missing ANTHROPIC_API_KEY');
+  return new ClaudeProvider(apiKey, process.env.CLAUDE_MODEL || 'claude-3-5-sonnet-latest');
+}

package/src/providers/geminiProvider.js

@@ -0,0 +1,55 @@
+import { assertHeaderSafeApiKey } from './auth';
+import { systemPrompt, userPrompt } from '../prompt';
+import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
+function extractText(json) {
+    const parts = json.candidates?.[0]?.content?.parts ?? [];
+    return parts
+        .map((p) => (typeof p.text === 'string' ? p.text : ''))
+        .join('')
+        .trim();
+}
+export class GeminiProvider {
+    apiKey;
+    model;
+    constructor(apiKey, model = 'gemini-2.0-flash') {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async nextNote(input) {
+        const apiKey = assertHeaderSafeApiKey('Gemini', this.apiKey);
+        const maxRetries = 4;
+        for (let attempt = 0;; attempt++) {
+            const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(this.model)}:generateContent?key=${encodeURIComponent(apiKey)}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    systemInstruction: {
+                        parts: [{ text: systemPrompt() }],
+                    },
+                    contents: [
+                        {
+                            role: 'user',
+                            parts: [{ text: 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(`Gemini request failed: ${res.status} ${text}`);
+            }
+            const json = (await res.json());
+            const text = extractText(json);
+            if (!text)
+                throw new Error('Gemini response missing text content');
+            return JSON.parse(text);
+        }
+    }
+}

package/src/providers/geminiProvider.ts

@@ -0,0 +1,71 @@
+import type { GeneratedNote, LLMProvider, NextNoteRequest } from '../types';
+import { assertHeaderSafeApiKey } from './auth';
+import { systemPrompt, userPrompt } from '../prompt';
+import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
+
+type GeminiResponse = {
+  candidates?: Array<{
+    content?: {
+      parts?: Array<{ text?: string }>;
+    };
+  }>;
+};
+
+function extractText(json: GeminiResponse): string {
+  const parts = json.candidates?.[0]?.content?.parts ?? [];
+  return parts
+    .map((p) => (typeof p.text === 'string' ? p.text : ''))
+    .join('')
+    .trim();
+}
+
+export class GeminiProvider implements LLMProvider {
+  constructor(
+    private readonly apiKey: string,
+    private readonly model = 'gemini-2.0-flash',
+  ) {}
+
+  async nextNote(input: NextNoteRequest): Promise<GeneratedNote> {
+    const apiKey = assertHeaderSafeApiKey('Gemini', this.apiKey);
+    const maxRetries = 4;
+
+    for (let attempt = 0; ; attempt++) {
+      const res = await fetch(
+        `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(this.model)}:generateContent?key=${encodeURIComponent(apiKey)}`,
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            systemInstruction: {
+              parts: [{ text: systemPrompt() }],
+            },
+            contents: [
+              {
+                role: 'user',
+                parts: [{ text: 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(`Gemini request failed: ${res.status} ${text}`);
+      }
+
+      const json = (await res.json()) as GeminiResponse;
+      const text = extractText(json);
+      if (!text) throw new Error('Gemini response missing text content');
+      return JSON.parse(text) as GeneratedNote;
+    }
+  }
+}
+

package/src/providers/grokProvider.js

@@ -0,0 +1,57 @@
+import { assertHeaderSafeApiKey } from './auth';
+import { systemPrompt, userPrompt } from '../prompt';
+import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
+function extractContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((c) => (typeof c?.text === 'string' ? c.text : ''))
+            .join('')
+            .trim();
+    }
+    return '';
+}
+export class GrokProvider {
+    apiKey;
+    model;
+    constructor(apiKey, model = 'grok-2-latest') {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async nextNote(input) {
+        const apiKey = assertHeaderSafeApiKey('Grok', this.apiKey);
+        const maxRetries = 4;
+        for (let attempt = 0;; attempt++) {
+            const res = await fetch('https://api.x.ai/v1/chat/completions', {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    model: this.model,
+                    temperature: 0.7,
+                    messages: [
+                        { role: 'system', content: systemPrompt() },
+                        { 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(`Grok request failed: ${res.status} ${text}`);
+            }
+            const json = (await res.json());
+            const text = extractContent(json.choices?.[0]?.message?.content);
+            if (!text)
+                throw new Error('Grok response missing content');
+            return JSON.parse(text);
+        }
+    }
+}

package/src/providers/grokProvider.ts

@@ -0,0 +1,69 @@
+import type { GeneratedNote, LLMProvider, NextNoteRequest } from '../types';
+import { assertHeaderSafeApiKey } from './auth';
+import { systemPrompt, userPrompt } from '../prompt';
+import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
+
+type ChatCompletionResponse = {
+  choices?: Array<{
+    message?: {
+      content?: string | Array<{ type?: string; text?: string }>;
+    };
+  }>;
+};
+
+type ChatContent = string | Array<{ type?: string; text?: string }> | undefined;
+
+function extractContent(content: ChatContent): string {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((c) => (typeof c?.text === 'string' ? c.text : ''))
+      .join('')
+      .trim();
+  }
+  return '';
+}
+
+export class GrokProvider implements LLMProvider {
+  constructor(
+    private readonly apiKey: string,
+    private readonly model = 'grok-2-latest',
+  ) {}
+
+  async nextNote(input: NextNoteRequest): Promise<GeneratedNote> {
+    const apiKey = assertHeaderSafeApiKey('Grok', this.apiKey);
+    const maxRetries = 4;
+    for (let attempt = 0; ; attempt++) {
+      const res = await fetch('https://api.x.ai/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          model: this.model,
+          temperature: 0.7,
+          messages: [
+            { role: 'system', content: systemPrompt() },
+            { 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(`Grok request failed: ${res.status} ${text}`);
+      }
+
+      const json = (await res.json()) as ChatCompletionResponse;
+      const text = extractContent(json.choices?.[0]?.message?.content);
+      if (!text) throw new Error('Grok response missing content');
+      return JSON.parse(text) as GeneratedNote;
+    }
+  }
+}

package/src/providers/groqProvider.js

@@ -0,0 +1,57 @@
+import { assertHeaderSafeApiKey } from './auth';
+import { systemPrompt, userPrompt } from '../prompt';
+import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
+function extractContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((c) => (typeof c?.text === 'string' ? c.text : ''))
+            .join('')
+            .trim();
+    }
+    return '';
+}
+export class GroqProvider {
+    apiKey;
+    model;
+    constructor(apiKey, model = 'llama-3.3-70b-versatile') {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async nextNote(input) {
+        const apiKey = assertHeaderSafeApiKey('Groq', this.apiKey);
+        const maxRetries = 4;
+        for (let attempt = 0;; attempt++) {
+            const res = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    model: this.model,
+                    temperature: 0.7,
+                    messages: [
+                        { role: 'system', content: systemPrompt() },
+                        { 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(`Groq request failed: ${res.status} ${text}`);
+            }
+            const json = (await res.json());
+            const text = extractContent(json.choices?.[0]?.message?.content);
+            if (!text)
+                throw new Error('Groq response missing content');
+            return JSON.parse(text);
+        }
+    }
+}

package/src/providers/groqProvider.ts

@@ -0,0 +1,69 @@
+import type { GeneratedNote, LLMProvider, NextNoteRequest } from '../types';
+import { assertHeaderSafeApiKey } from './auth';
+import { systemPrompt, userPrompt } from '../prompt';
+import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
+
+type ChatCompletionResponse = {
+  choices?: Array<{
+    message?: {
+      content?: string | Array<{ type?: string; text?: string }>;
+    };
+  }>;
+};
+
+type ChatContent = string | Array<{ type?: string; text?: string }> | undefined;
+
+function extractContent(content: ChatContent): string {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((c) => (typeof c?.text === 'string' ? c.text : ''))
+      .join('')
+      .trim();
+  }
+  return '';
+}
+
+export class GroqProvider implements LLMProvider {
+  constructor(
+    private readonly apiKey: string,
+    private readonly model = 'llama-3.3-70b-versatile',
+  ) {}
+
+  async nextNote(input: NextNoteRequest): Promise<GeneratedNote> {
+    const apiKey = assertHeaderSafeApiKey('Groq', this.apiKey);
+    const maxRetries = 4;
+    for (let attempt = 0; ; attempt++) {
+      const res = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          model: this.model,
+          temperature: 0.7,
+          messages: [
+            { role: 'system', content: systemPrompt() },
+            { 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(`Groq request failed: ${res.status} ${text}`);
+      }
+
+      const json = (await res.json()) as ChatCompletionResponse;
+      const text = extractContent(json.choices?.[0]?.message?.content);
+      if (!text) throw new Error('Groq response missing content');
+      return JSON.parse(text) as GeneratedNote;
+    }
+  }
+}

package/src/providers/mockProvider.js

@@ -0,0 +1,13 @@
+// Simple fallback provider for local testing without API keys.
+export class MockProvider {
+    async nextNote(input) {
+        const last = input.history.at(-1)?.pitch ?? input.seedPitch;
+        const stepChoices = [-2, -1, 1, 2, 3];
+        const step = stepChoices[Math.floor(Math.random() * stepChoices.length)];
+        return {
+            pitch: Math.max(48, Math.min(84, last + step)),
+            velocity: 90,
+            durationMs: 300,
+        };
+    }
+}

package/src/providers/mockProvider.ts

@@ -0,0 +1,15 @@
+import type { GeneratedNote, LLMProvider, NextNoteRequest } from '../types';
+
+// Simple fallback provider for local testing without API keys.
+export class MockProvider implements LLMProvider {
+  async nextNote(input: NextNoteRequest): Promise<GeneratedNote> {
+    const last = input.history.at(-1)?.pitch ?? input.seedPitch;
+    const stepChoices = [-2, -1, 1, 2, 3];
+    const step = stepChoices[Math.floor(Math.random() * stepChoices.length)];
+    return {
+      pitch: Math.max(48, Math.min(84, last + step)),
+      velocity: 90,
+      durationMs: 300,
+    };
+  }
+}

package/src/providers/openaiProvider.js

@@ -0,0 +1,45 @@
+import { assertHeaderSafeApiKey } from './auth';
+import { systemPrompt, userPrompt } from '../prompt';
+import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
+export class OpenAIProvider {
+    apiKey;
+    model;
+    constructor(apiKey, model = 'gpt-4.1-mini') {
+        this.apiKey = apiKey;
+        this.model = model;
+    }
+    async nextNote(input) {
+        const apiKey = assertHeaderSafeApiKey('OpenAI', this.apiKey);
+        const maxRetries = 4;
+        for (let attempt = 0;; attempt++) {
+            const res = await fetch('https://api.openai.com/v1/responses', {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    model: this.model,
+                    input: [
+                        { role: 'system', content: [{ type: 'input_text', text: systemPrompt() }] },
+                        { role: 'user', content: [{ type: 'input_text', text: 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(`OpenAI request failed: ${res.status} ${text}`);
+            }
+            const json = await res.json();
+            if (!json.output_text) {
+                throw new Error('OpenAI response missing output_text');
+            }
+            return JSON.parse(json.output_text);
+        }
+    }
+}

package/src/providers/openaiProvider.ts

@@ -0,0 +1,49 @@
+import type { GeneratedNote, LLMProvider, NextNoteRequest } from '../types';
+import { assertHeaderSafeApiKey } from './auth';
+import { systemPrompt, userPrompt } from '../prompt';
+import { computeRetryDelayMs, shouldRetryStatus, waitForRetry } from './retry';
+
+export class OpenAIProvider implements LLMProvider {
+  constructor(
+    private readonly apiKey: string,
+    private readonly model = 'gpt-4.1-mini',
+  ) {}
+
+  async nextNote(input: NextNoteRequest): Promise<GeneratedNote> {
+    const apiKey = assertHeaderSafeApiKey('OpenAI', this.apiKey);
+    const maxRetries = 4;
+    for (let attempt = 0; ; attempt++) {
+      const res = await fetch('https://api.openai.com/v1/responses', {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          model: this.model,
+          input: [
+            { role: 'system', content: [{ type: 'input_text', text: systemPrompt() }] },
+            { role: 'user', content: [{ type: 'input_text', text: 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(`OpenAI request failed: ${res.status} ${text}`);
+      }
+
+      const json = await res.json() as { output_text?: string };
+      if (!json.output_text) {
+        throw new Error('OpenAI response missing output_text');
+      }
+
+      return JSON.parse(json.output_text) as GeneratedNote;
+    }
+  }
+}

package/src/providers/retry.js

@@ -0,0 +1,46 @@
+const RETRYABLE_STATUS = new Set([408, 409, 425, 429, 500, 502, 503, 504]);
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseRetryAfterMs(value) {
+    if (!value)
+        return null;
+    const sec = Number.parseFloat(value);
+    if (Number.isFinite(sec) && sec >= 0)
+        return Math.round(sec * 1000);
+    const date = Date.parse(value);
+    if (!Number.isNaN(date)) {
+        const diff = date - Date.now();
+        return diff > 0 ? diff : 0;
+    }
+    return null;
+}
+function parseTryAgainMs(text) {
+    const match = text.match(/try again in\s+(\d+(?:\.\d+)?)s/i);
+    if (!match)
+        return null;
+    const sec = Number.parseFloat(match[1]);
+    if (!Number.isFinite(sec) || sec < 0)
+        return null;
+    return Math.round(sec * 1000);
+}
+function backoffMs(attempt) {
+    const base = 500 * Math.pow(2, attempt);
+    const jitter = Math.floor(Math.random() * 250);
+    return base + jitter;
+}
+export function shouldRetryStatus(status) {
+    return RETRYABLE_STATUS.has(status);
+}
+export function computeRetryDelayMs(headersRetryAfter, responseText, attempt) {
+    const fromHeader = parseRetryAfterMs(headersRetryAfter);
+    if (fromHeader != null)
+        return Math.min(10_000, Math.max(250, fromHeader));
+    const fromBody = parseTryAgainMs(responseText);
+    if (fromBody != null)
+        return Math.min(10_000, Math.max(250, fromBody));
+    return Math.min(10_000, backoffMs(attempt));
+}
+export async function waitForRetry(ms) {
+    await sleep(ms);
+}