@hraness/dawg 0.2.0 → 0.3.0

package/src/audio/wav.ts

@@ -1,5 +1,6 @@
 import {
   SCORE_LIMITS,
+  isSamplerInstrument,
   isTrackAudible,
   type AutomationPoint,
   type Note,
@@ -7,6 +8,12 @@ import {
   type TrackScore,
 } from "../../core/score.ts";
 import { drumVoiceForPitch, isDrumInstrument } from "../../core/drums.ts";
+import {
+  planSamplerVoices,
+  renderSamplerVoices,
+  samplerTailSeconds,
+} from "./sampler.ts";
+import { EMPTY_SAMPLE_BANK, sampleKey, type SampleBank } from "./samples.ts";
 
 export type WavOptions = Readonly<{ sampleRate?: number; maxSeconds?: number }>;
 
@@ -18,6 +25,11 @@ export type RenderOptions = WavOptions &
      * what the streaming engine plays; exports keep the default one-shot.
      */
     loop?: boolean;
+    /**
+     * Decoded sampler voices (`SampleLibrary.load`). Without it sampler
+     * tracks render silent; scores without samplers are unaffected.
+     */
+    samples?: SampleBank;
   }>;
 
 /** Interleaved stereo 16-bit PCM plus its frame count. */
@@ -83,7 +95,7 @@ export function clampSampleRate(sampleRate?: number): number {
 /** Render the bounded score to a stereo 16-bit PCM WAV. */
 export function renderScoreWav(
   score: TrackScore,
-  options: WavOptions = {},
+  options: WavOptions & Pick<RenderOptions, "samples"> = {},
 ): Uint8Array {
   const audio = renderScorePcm(score, options);
   return encodeWav(audio.pcm, audio.sampleRate, RENDER_CHANNELS);
@@ -98,92 +110,294 @@ export function renderScorePcm(
   score: TrackScore,
   options: RenderOptions = {},
 ): RenderedAudio {
-  const sampleRate = clampSampleRate(options.sampleRate);
-  const maxSeconds = Math.max(1, Math.min(60, options.maxSeconds ?? 30));
-  const loopSeconds = (score.bars * score.beatsPerBar * 60) / score.tempoBpm;
-  const reverbTail = Math.max(
-    0,
-    ...score.tracks.map((track) =>
-      track.reverb && track.reverb.mix > 0 ? 1 + 3 * track.reverb.size : 0,
-    ),
-  );
-  let frames: number;
-  let samples: number;
-  if (options.loop) {
-    frames = Math.max(
-      1,
-      Math.min(
-        Math.round(loopFrames(score, sampleRate)),
-        Math.ceil(maxSeconds * sampleRate),
+  return new StemRenderer({ maxCacheBytes: 0 }).render(score, options);
+}
+
+/** Default byte budget for cached per-track stems. */
+export const DEFAULT_STEM_CACHE_BYTES = 256 * 1024 * 1024;
+
+type Stem = {
+  key: string;
+  left: Float64Array;
+  right: Float64Array;
+  bytes: number;
+  used: number;
+};
+
+/**
+ * The renderer behind `renderScorePcm`, with a per-track stem cache. Each
+ * track's stereo stem (after its own effects) is keyed by everything that
+ * shapes it: the track settings, its notes, tempo, tick resolution, sample
+ * rate and buffer length. Edits re-render only the tracks whose key changed
+ * and sum the cached rest in the original order, so the result is
+ * byte-identical to a cold render; mute and solo only pick which stems are
+ * summed. Scratch buffers are reused across renders.
+ */
+export class StemRenderer {
+  private readonly maxCacheBytes: number;
+  private readonly stems = new Map<string, Stem>();
+  private cacheBytes = 0;
+  private renders = 0;
+  private scratch: {
+    dry: Float64Array;
+    left: Float64Array;
+    right: Float64Array;
+    mixL: Float64Array;
+    mixR: Float64Array;
+  } = {
+    dry: new Float64Array(0),
+    left: new Float64Array(0),
+    right: new Float64Array(0),
+    mixL: new Float64Array(0),
+    mixR: new Float64Array(0),
+  };
+
+  public constructor(options: Readonly<{ maxCacheBytes?: number }> = {}) {
+    this.maxCacheBytes = Math.max(
+      0,
+      options.maxCacheBytes ?? DEFAULT_STEM_CACHE_BYTES,
+    );
+  }
+
+  /** Cached stems and their total size, for tests and diagnostics. */
+  public get cache(): Readonly<{ stems: number; bytes: number }> {
+    return { stems: this.stems.size, bytes: this.cacheBytes };
+  }
+
+  public render(score: TrackScore, options: RenderOptions = {}): RenderedAudio {
+    const sampleRate = clampSampleRate(options.sampleRate);
+    const maxSeconds = Math.max(1, Math.min(60, options.maxSeconds ?? 30));
+    const loopSeconds = (score.bars * score.beatsPerBar * 60) / score.tempoBpm;
+    const reverbTail = Math.max(
+      0,
+      ...score.tracks.map((track) =>
+        track.reverb && track.reverb.mix > 0 ? 1 + 3 * track.reverb.size : 0,
       ),
     );
-    const tailSeconds = Math.min(
+    const bank = options.samples ?? EMPTY_SAMPLE_BANK;
+    // Zero without sampler voices, so synth-only renders are unchanged.
+    const samplerTail = Math.min(
       MAX_LOOP_TAIL_SECONDS,
-      MAX_DRUM_SECONDS + 0.1 + reverbTail + delayTailSeconds(score),
-    );
-    samples = frames + Math.ceil(tailSeconds * sampleRate);
-  } else {
-    const seconds = Math.min(
-      maxSeconds,
-      loopSeconds + ONE_SHOT_TAIL_SECONDS + reverbTail,
+      samplerTailSeconds(score, bank, sampleRate),
     );
-    frames = Math.max(1, Math.ceil(seconds * sampleRate));
-    samples = frames;
-  }
-  const context: RenderContext = {
-    score,
-    sampleRate,
-    samples,
-    samplesPerTick: (sampleRate * 60) / (score.tempoBpm * score.ticksPerBeat),
-  };
-  // Tracks render one at a time into reused scratch buffers so per-track
-  // effects stay bounded in memory regardless of the track count.
-  const mixL = new Float64Array(samples);
-  const mixR = new Float64Array(samples);
-  const dry = new Float64Array(samples);
-  const left = new Float64Array(samples);
-  const right = new Float64Array(samples);
-  const tracks = new Map(score.tracks.map((track) => [track.id, track]));
-  const groups = new Map<string, Note[]>();
-  for (const note of score.notes) {
-    const group = groups.get(note.trackId);
-    if (group) group.push(note);
-    else groups.set(note.trackId, [note]);
-  }
-  for (const [trackId, notes] of groups) {
-    if (!isTrackAudible(score, trackId)) continue;
-    const track = tracks.get(trackId);
-    dry.fill(0);
-    const drums = isDrumInstrument(track?.instrument);
-    for (const note of notes) {
-      if (drums) renderDrumNote(dry, note, track, context);
-      else renderToneNote(dry, note, track, context);
+    let frames: number;
+    let samples: number;
+    if (options.loop) {
+      frames = Math.max(
+        1,
+        Math.min(
+          Math.round(loopFrames(score, sampleRate)),
+          Math.ceil(maxSeconds * sampleRate),
+        ),
+      );
+      const tailSeconds = Math.min(
+        MAX_LOOP_TAIL_SECONDS,
+        Math.max(MAX_DRUM_SECONDS, samplerTail) +
+          0.1 +
+          reverbTail +
+          delayTailSeconds(score),
+      );
+      samples = frames + Math.ceil(tailSeconds * sampleRate);
+    } else {
+      const seconds = Math.min(
+        maxSeconds,
+        loopSeconds + Math.max(ONE_SHOT_TAIL_SECONDS, samplerTail) + reverbTail,
+      );
+      frames = Math.max(1, Math.ceil(seconds * sampleRate));
+      samples = frames;
     }
-    if (track) applyLowPass(dry, track, context);
-    applyPan(dry, left, right, track, context);
-    if (track) {
-      applyDelay(left, right, track, context);
-      applyReverb(left, right, track, context);
+    const context: RenderContext = {
+      score,
+      sampleRate,
+      samples,
+      samplesPerTick: (sampleRate * 60) / (score.tempoBpm * score.ticksPerBeat),
+    };
+    this.renders += 1;
+    const { dry, left, right, mixL, mixR } = this.scratchFor(samples);
+    mixL.fill(0);
+    mixR.fill(0);
+    const tracks = new Map(score.tracks.map((track) => [track.id, track]));
+    const groups = new Map<string, Note[]>();
+    for (const note of score.notes) {
+      const group = groups.get(note.trackId);
+      if (group) group.push(note);
+      else groups.set(note.trackId, [note]);
     }
-    for (let index = 0; index < samples; index += 1) {
-      mixL[index]! += left[index]!;
-      mixR[index]! += right[index]!;
+    // Tracks render one at a time; the sum order (first note per track) is
+    // part of the output, so cached and cold renders keep it.
+    for (const [trackId, notes] of groups) {
+      if (!isTrackAudible(score, trackId)) continue;
+      const track = tracks.get(trackId);
+      const sampler = isSamplerInstrument(track?.instrument);
+      const key = stemKey(track, notes, context, sampler ? bank : undefined);
+      let stem = this.stems.get(trackId);
+      if (stem?.key === key) stem.used = this.renders;
+      else {
+        const caching = this.maxCacheBytes > 0;
+        const target = caching
+          ? {
+              left: new Float64Array(samples),
+              right: new Float64Array(samples),
+            }
+          : { left, right };
+        dry.fill(0);
+        if (sampler) {
+          if (track) renderSamplerNotes(dry, notes, track, context, bank);
+        } else {
+          const drums = isDrumInstrument(track?.instrument);
+          for (const note of notes) {
+            if (drums) renderDrumNote(dry, note, track, context);
+            else renderToneNote(dry, note, track, context);
+          }
+        }
+        if (track) applyLowPass(dry, track, context);
+        applyPan(dry, target.left, target.right, track, context);
+        if (track) {
+          applyDelay(target.left, target.right, track, context);
+          applyReverb(target.left, target.right, track, context);
+        }
+        stem = {
+          key,
+          left: target.left,
+          right: target.right,
+          bytes: target.left.byteLength + target.right.byteLength,
+          used: this.renders,
+        };
+        if (caching) this.store(trackId, stem);
+      }
+      for (let index = 0; index < samples; index += 1) {
+        mixL[index]! += stem.left[index]!;
+        mixR[index]! += stem.right[index]!;
+      }
     }
+    // Stems of tracks that left the score are not worth keeping; muted and
+    // unsoloed tracks keep theirs so toggling them back is free.
+    for (const trackId of [...this.stems.keys()])
+      if (!groups.has(trackId)) this.evict(trackId);
+    if (samples > frames) {
+      // Linear effects superpose, so folding the tail onto the start yields
+      // the steady state of the loop playing forever.
+      for (let index = frames; index < samples; index += 1) {
+        mixL[index % frames]! += mixL[index]!;
+        mixR[index % frames]! += mixR[index]!;
+      }
+    }
+    const pcm = new Int16Array(frames * RENDER_CHANNELS);
+    for (let index = 0; index < frames; index += 1) {
+      pcm[index * 2] = clamp16(mixL[index]! * 32767);
+      pcm[index * 2 + 1] = clamp16(mixR[index]! * 32767);
+    }
+    return Object.freeze({
+      sampleRate,
+      channels: RENDER_CHANNELS,
+      frames,
+      pcm,
+    });
   }
-  if (samples > frames) {
-    // Linear effects superpose, so folding the tail onto the start yields
-    // the steady state of the loop playing forever.
-    for (let index = frames; index < samples; index += 1) {
-      mixL[index % frames]! += mixL[index]!;
-      mixR[index % frames]! += mixR[index]!;
+
+  private scratchFor(samples: number) {
+    if (this.scratch.dry.length < samples) {
+      this.scratch = {
+        dry: new Float64Array(samples),
+        left: new Float64Array(samples),
+        right: new Float64Array(samples),
+        mixL: new Float64Array(samples),
+        mixR: new Float64Array(samples),
+      };
     }
+    const view = (buffer: Float64Array) => buffer.subarray(0, samples);
+    return {
+      dry: view(this.scratch.dry),
+      left: view(this.scratch.left),
+      right: view(this.scratch.right),
+      mixL: view(this.scratch.mixL),
+      mixR: view(this.scratch.mixR),
+    };
   }
-  const pcm = new Int16Array(frames * RENDER_CHANNELS);
-  for (let index = 0; index < frames; index += 1) {
-    pcm[index * 2] = clamp16(mixL[index]! * 32767);
-    pcm[index * 2 + 1] = clamp16(mixR[index]! * 32767);
+
+  private store(trackId: string, stem: Stem): void {
+    this.evict(trackId);
+    // Make room by dropping the least recently used stems from other
+    // renders; a score whose stems exceed the budget is simply not cached.
+    while (
+      this.cacheBytes + stem.bytes > this.maxCacheBytes &&
+      this.stems.size > 0
+    ) {
+      let oldest: string | undefined;
+      for (const [id, candidate] of this.stems)
+        if (
+          candidate.used !== this.renders &&
+          (oldest === undefined ||
+            candidate.used < this.stems.get(oldest)!.used)
+        )
+          oldest = id;
+      if (oldest === undefined) break;
+      this.evict(oldest);
+    }
+    if (this.cacheBytes + stem.bytes > this.maxCacheBytes) return;
+    this.stems.set(trackId, stem);
+    this.cacheBytes += stem.bytes;
+  }
+
+  private evict(trackId: string): void {
+    const stem = this.stems.get(trackId);
+    if (!stem) return;
+    this.stems.delete(trackId);
+    this.cacheBytes -= stem.bytes;
   }
-  return Object.freeze({ sampleRate, channels: RENDER_CHANNELS, frames, pcm });
+}
+
+/** Everything a track's stem depends on, except mute and solo. */
+function stemKey(
+  track: Track | undefined,
+  notes: readonly Note[],
+  context: RenderContext,
+  bank?: SampleBank,
+): string {
+  let settings: Record<string, unknown> | null = null;
+  if (track) {
+    const { muted: _muted, solo: _solo, ...rest } = track;
+    settings = rest;
+  }
+  return JSON.stringify([
+    settings,
+    notes,
+    context.score.tempoBpm,
+    context.score.ticksPerBeat,
+    context.sampleRate,
+    context.samples,
+    // Sampler stems also depend on the decoded files: a replaced or missing
+    // sample changes the key even when the score did not change.
+    ...(bank && track?.sampler ? [samplerVoiceDigest(track, bank)] : []),
+  ]);
+}
+
+function samplerVoiceDigest(track: Track, bank: SampleBank): string[] {
+  return Object.keys(track.sampler?.voices ?? {})
+    .sort()
+    .map((voice) => {
+      const sample = bank.voices.get(sampleKey(track.id, voice));
+      return sample
+        ? `${voice}:${sample.sha256}:${sample.sampleRate}:${sample.frames}`
+        : `${voice}:-`;
+    });
+}
+
+/** Sample voices of a sampler track into its mono dry buffer. */
+function renderSamplerNotes(
+  target: Float64Array,
+  notes: readonly Note[],
+  track: Track,
+  context: RenderContext,
+  bank: SampleBank,
+): void {
+  const timing = { score: context.score, sampleRate: context.sampleRate };
+  renderSamplerVoices(
+    target,
+    planSamplerVoices(track, notes, bank, timing),
+    timing,
+    (tick) => trackGainAt(track, tick),
+  );
 }
 
 /** Seconds until the slowest delay decays below -60 dB, bounded. */

package/src/auth/cli.ts

@@ -1,26 +1,44 @@
 import { hostname } from "node:os";
 import { createInterface } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
-import { defaultAuthEnv } from "./credentials.ts";
+import {
+  defaultAuthEnv,
+  readConfig,
+  writeConfig,
+  type DawgConfig,
+} from "./credentials.ts";
 import {
   authStatus,
+  isLogoutTarget,
   login,
   logout,
+  modelCommand,
   type LoginIO,
-  type LoginMode,
+  type LoginOptions,
+  type LoginTarget,
 } from "./login.ts";
-import { systemRunner } from "./runner.ts";
+import { LOGIN_OPTIONS } from "./discover.ts";
+import { chooseOnTerminal } from "./picker.ts";
+import { systemRunner, type CommandRunner } from "./runner.ts";
+import { selectProvider } from "../agent/provider.ts";
 import { audioStatusLine } from "../audio/engine.ts";
 
 export const AUTH_USAGE = `Usage:
-  dawg login            create an AI Gateway key with the Vercel CLI (default)
-  dawg login --key      paste an existing AI Gateway key (hidden input)
-  dawg login --xcb      use a Claude/Codex/Devin subscription through xcb
-  dawg login --budget <dollars>   spend limit for the created key
-  dawg logout           remove the stored key and provider choice
-  dawg auth status [--check]      show provider, key, xcb account, audio backend`;
+  dawg login                  find existing setups and pick a provider (reuses a saved one)
+  dawg login gateway          Vercel AI Gateway: existing key, or create one with the Vercel CLI
+  dawg login openrouter       OpenRouter: sign in through your browser (OAuth PKCE)
+  dawg login codex            ChatGPT/Codex subscription through xcb
+  dawg login claude           Claude subscription through xcb
+  dawg login --pick           show the picker even when a provider is saved
+  dawg login --key            paste an AI Gateway key (hidden input)
+  dawg login --xcb            any xcb account (Devin included)
+  dawg login gateway --budget <dollars>   spend limit for a created key
+  dawg login codex|claude [--account <id>] [--model <key>]
+  dawg model [<alias>|<vendor/model>]     pick the model (cost per prompt shown)
+  dawg logout [gateway|openrouter|codex|claude|xcb]   forget keys and the saved choice
+  dawg auth status [--check]  every provider: detected, active, validated`;
 
-/** Entry for `dawg login|logout|auth`. Returns the process exit code. */
+/** Entry for `dawg login|logout|auth|model`. Returns the process exit code. */
 export async function runAuthCommand(argv: readonly string[]): Promise<number> {
   const [command, ...rest] = argv;
   const io = terminalIO();
@@ -29,7 +47,15 @@ export async function runAuthCommand(argv: readonly string[]): Promise<number> {
     io.print(AUTH_USAGE);
     return 0;
   }
-  if (command === "logout") return logout(deps);
+  if (command === "logout") {
+    const target = rest[0];
+    if (target !== undefined && !isLogoutTarget(target)) {
+      io.print(AUTH_USAGE);
+      return 2;
+    }
+    return logout(deps, target);
+  }
+  if (command === "model") return modelCommand(deps, rest[0]);
   if (command === "auth") {
     if (
       rest[0] !== undefined &&
@@ -41,30 +67,117 @@ export async function runAuthCommand(argv: readonly string[]): Promise<number> {
     }
     for (const line of await authStatus(deps, {
       verify: rest.includes("--check"),
+      onProgress: (line) => io.print(line),
     }))
       io.print(line);
     io.print(audioStatusLine());
     return 0;
   }
-  const flags = new Set(rest.filter((arg) => arg.startsWith("--")));
-  const mode: LoginMode = flags.has("--xcb")
-    ? "xcb"
-    : flags.has("--key")
-      ? "key"
-      : "gateway";
-  let budget: number | undefined;
-  const budgetIndex = rest.indexOf("--budget");
-  if (budgetIndex >= 0) {
-    budget = Number(rest[budgetIndex + 1]);
-    if (!Number.isFinite(budget) || budget < 1 || budget > 1_000_000) {
-      io.print("--budget takes a dollar amount of at least 1");
-      return 2;
-    }
+  const parsed = parseLoginArgs(rest);
+  if (typeof parsed === "string") {
+    io.print(parsed);
+    io.print(AUTH_USAGE);
+    return 2;
+  }
+  return login(parsed.target, deps, parsed.options);
+}
+
+/**
+ * The first run of `dawg` in a terminal: when nothing is configured (and the
+ * picker was never dismissed), or a saved sign-in stopped working, show the
+ * sign-in picker before the TUI starts. Dismissing it is remembered.
+ */
+export async function runFirstRunLogin(
+  runner: CommandRunner = systemRunner,
+): Promise<void> {
+  const auth = defaultAuthEnv(runner);
+  const config = await readConfig(auth).catch(() => ({}) as DawgConfig);
+  if (auth.env.DAWG_PROVIDER) return;
+  if (!config.provider && config.setup === "skipped") return;
+  const selection = await selectProvider(auth).catch(() => undefined);
+  if (!selection || selection.kind !== "offline") return;
+  if (config.provider && !selection.invalidSaved) return;
+  const io = terminalIO();
+  if (!io.interactive) return;
+  if (selection.invalidSaved)
+    io.print(`Your saved sign-in stopped working: ${selection.reason}.`);
+  else io.print("Welcome to dawg. Sign in to enable the agent (Esc to skip).");
+  const code = await login("pick", {
+    auth,
+    io,
+    hostname: hostname(),
+  }).catch((error: unknown) => {
+    io.print(
+      `sign-in failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    return 1;
+  });
+  if (code !== 0 && !config.provider)
+    await writeConfig(auth, { setup: "skipped" }).catch(() => undefined);
+}
+
+/** `/login` in the TUI, run while the screen is handed back to the shell. */
+export async function runTuiLogin(
+  target: LoginTarget,
+  options: LoginOptions,
+  runner: CommandRunner = systemRunner,
+): Promise<number> {
+  const io = terminalIO();
+  return login(
+    target,
+    {
+      auth: defaultAuthEnv(runner),
+      io,
+      hostname: hostname(),
+    },
+    options,
+  ).catch((error: unknown) => {
+    io.print(
+      `sign-in failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    return 1;
+  });
+}
+
+export function parseLoginArgs(
+  args: readonly string[],
+): { target: LoginTarget; options: LoginOptions } | string {
+  const options: LoginOptions = {};
+  let target: LoginTarget = "auto";
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index]!;
+    const value = () => {
+      const next = args[index + 1];
+      index += 1;
+      return next && !next.startsWith("--") ? next : undefined;
+    };
+    if ((LOGIN_OPTIONS as readonly string[]).includes(arg))
+      target = arg as LoginTarget;
+    else if (arg === "--gateway") target = "gateway";
+    else if (arg === "--openrouter") target = "openrouter";
+    else if (arg === "--xcb") target = "xcb";
+    else if (arg === "--key") target = "key";
+    else if (arg === "--pick") target = "pick";
+    else if (arg === "--budget") {
+      const budget = Number(value());
+      if (!Number.isFinite(budget) || budget < 1 || budget > 1_000_000)
+        return "--budget takes a dollar amount of at least 1";
+      options.budget = budget;
+      if (target === "auto") target = "gateway";
+    } else if (arg === "--account") {
+      const account = value();
+      if (!account) return "--account needs an account id";
+      options.account = account;
+    } else if (arg === "--model") {
+      const model = value();
+      if (!model) return "--model needs a model key";
+      options.model = model;
+    } else return `unknown argument: ${arg.slice(0, 40)}`;
   }
-  return login(mode, deps, budget === undefined ? {} : { budget });
+  return { target, options };
 }
 
-function terminalIO(): LoginIO {
+export function terminalIO(): LoginIO {
   return {
     interactive: Boolean(stdin.isTTY && stdout.isTTY),
     print: (line) => void stdout.write(`${line}\n`),
@@ -77,6 +190,12 @@ function terminalIO(): LoginIO {
       }
     },
     readSecret: (prompt) => readHidden(prompt),
+    ...(stdin.isTTY && stdout.isTTY
+      ? {
+          choose: (title, items, options) =>
+            chooseOnTerminal(title, items, options),
+        }
+      : {}),
   };
 }