@hraness/dawg 0.6.1 → 0.8.0

package/src/agent/portable-schema.ts

@@ -0,0 +1,80 @@
+/**
+ * Tool parameter schemas as every provider accepts them.
+ *
+ * dawg writes unions as `type: ["array", "string"]` with `items` beside it.
+ * OpenAI and Anthropic accept that, but Gemini (through the AI Gateway)
+ * rewrites the union to `anyOf` and leaves `items` outside, then rejects the
+ * whole request, so no Gemini model could run a turn. Here each union
+ * becomes an `anyOf` whose branches carry only their own keywords, and an
+ * array branch always has `items`.
+ */
+
+type Schema = Record<string, unknown>;
+
+/** Keywords that belong to one JSON type's branch of a union. */
+const BRANCH_KEYWORDS: Readonly<Record<string, readonly string[]>> = {
+  array: ["items", "minItems", "maxItems"],
+  object: ["properties", "required", "additionalProperties"],
+  string: ["enum", "minLength", "maxLength", "pattern"],
+  number: ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum"],
+  integer: ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum"],
+};
+const ALL_BRANCH_KEYWORDS = new Set(Object.values(BRANCH_KEYWORDS).flat());
+
+/** Items for an array branch that declared none: any scalar. */
+const ANY_SCALAR_ITEMS: Schema = {
+  anyOf: [{ type: "number" }, { type: "string" }, { type: "boolean" }],
+};
+
+function isSchema(value: unknown): value is Schema {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function branch(type: string, schema: Schema): Schema {
+  const out: Schema = { type };
+  for (const key of BRANCH_KEYWORDS[type] ?? []) {
+    if (!(key in schema)) continue;
+    const value = schema[key];
+    // An enum only constrains the branch whose type its values have.
+    if (key === "enum" && Array.isArray(value)) {
+      const kept = value.filter((v) => typeof v === "string");
+      if (kept.length > 0) out.enum = kept;
+      continue;
+    }
+    out[key] = value;
+  }
+  if (type === "array" && out.items === undefined) out.items = ANY_SCALAR_ITEMS;
+  return portableSchema(out);
+}
+
+/** A copy of `schema` with every type union rewritten as `anyOf`. */
+export function portableSchema(schema: unknown): Schema {
+  if (!isSchema(schema)) return schema as Schema;
+  const out: Schema = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "properties" && isSchema(value)) {
+      out.properties = Object.fromEntries(
+        Object.entries(value).map(([name, sub]) => [name, portableSchema(sub)]),
+      );
+    } else if (
+      (key === "items" || key === "additionalProperties") &&
+      isSchema(value)
+    ) {
+      out[key] = portableSchema(value);
+    } else if ((key === "anyOf" || key === "oneOf") && Array.isArray(value)) {
+      out[key] = value.map(portableSchema);
+    } else {
+      out[key] = value;
+    }
+  }
+  if (Array.isArray(out.type)) {
+    const types = out.type as string[];
+    const rest: Schema = {};
+    for (const [key, value] of Object.entries(out))
+      if (key !== "type" && !ALL_BRANCH_KEYWORDS.has(key)) rest[key] = value;
+    return { ...rest, anyOf: types.map((type) => branch(type, out)) };
+  }
+  if (out.type === "array" && out.items === undefined)
+    out.items = ANY_SCALAR_ITEMS;
+  return out;
+}

package/src/agent/preview-tool.ts

@@ -23,6 +23,7 @@ import {
 } from "../audio/preview.ts";
 import { renderScorePcm, type RenderedAudio } from "../audio/wav.ts";
 import type { ScoreMeasurement } from "../audio/measure.ts";
+import { VOICE_PREVIEWABLE_TOOLS } from "./voice-tools.ts";
 import type {
   ActionContext,
   AgentTool,
@@ -48,6 +49,8 @@ export const PREVIEWABLE_TOOLS: readonly string[] = Object.freeze([
   "set_granular",
   "set_drum_kit",
   "use_sound",
+  // 0.7 Voice: flagged per lane in voice-tools.ts.
+  ...VOICE_PREVIEWABLE_TOOLS,
 ]);
 
 const MAX_CHANGES = 8;
@@ -160,7 +163,7 @@ export function previewSoundTool(
   return {
     name: "preview_sound",
     description:
-      "Hear a track, or a candidate sound change, without committing it. changes: sound tool calls to try ({tool, args} for set_fx, set_rig, set_synth, set_string, set_modal, set_wind, set_wavetable, set_instrument, set_sample, fit_sample, set_effects, set_mix, set_automation, set_drum_kit, use_sound), applied to a copy. Renders the track's notes over up to 4 bars (or a short phrase by role when it has none), solo or in context, and returns RMS/peak dBFS, spectral centroid and a one-line description for the current and the candidate sound. When the user's window is open it plays the snippet once. Then commit with the normal tools if it sounds right.",
+      "Hear a track, or a candidate sound change, without committing it. changes: sound tool calls to try ({tool, args} for set_fx, set_rig, set_synth, set_string, set_modal, set_wind, set_wavetable, set_instrument, set_sample, fit_sample, set_mix, set_automation, set_drum_kit, use_sound), applied to a copy. Renders the track's notes over up to 4 bars (or a short phrase by role when it has none), solo or in context, and returns RMS/peak dBFS, spectral centroid and a one-line description for the current and the candidate sound. When the user's window is open it plays the snippet once. Then commit with the normal tools if it sounds right.",
     parameters: {
       type: "object",
       properties: {

package/src/agent/provider.ts

@@ -1,3 +1,4 @@
+import { runCommandAgentTurn } from "./command-agent.ts";
 import { statSync } from "node:fs";
 import { join } from "node:path";
 import {
@@ -29,6 +30,7 @@ import {
 } from "./gateway.ts";
 import {
   defaultModelId,
+  fallbackModelId,
   MODEL_CATALOG,
   modelAlias,
   resolveModelChoice,
@@ -90,7 +92,7 @@ export function isApiSelection(
   return selection.kind === "gateway" || selection.kind === "openrouter";
 }
 
-export const LOGIN_HINT = "run `dawg login` to enable the agent";
+export const LOGIN_HINT = "run `dawg model key` to enable the agent";
 /** The small, cheap model used for one-line helpers such as session names. */
 export const GATEWAY_SMALL_MODEL = "anthropic/claude-haiku-4.5";
 export const OPENROUTER_SMALL_MODEL = "anthropic/claude-haiku-4.5";
@@ -113,7 +115,7 @@ export function providerChoice(
 
 /**
  * The model for a key-based provider: `DAWG_MODEL`, then the model saved by
- * `/model` or `dawg login`, then Opus 5.5. Throws on an unknown `DAWG_MODEL`.
+ * `/model` or `dawg model key`, then Opus 5.5. Throws on an unknown `DAWG_MODEL`.
  */
 export function apiModelId(
   service: ApiProvider,
@@ -186,14 +188,14 @@ export async function selectProvider(
     }
     if (choice === service)
       return offline(
-        `no ${service === "gateway" ? "AI Gateway" : "OpenRouter"} key any more; run \`dawg login ${service}\``,
+        `no ${service === "gateway" ? "AI Gateway" : "OpenRouter"} key any more; run \`dawg model key ${service}\``,
       );
   }
   const bin = resolveXcbBin(auth.env, auth.runner);
   if (!bin)
     return offline(
       explicit
-        ? `xcb is not installed; run \`dawg login ${choice === "xcb" ? "--xcb" : choice}\``
+        ? `xcb is not installed; run \`dawg model key ${choice === "xcb" ? "--xcb" : choice}\``
         : `no model configured; ${LOGIN_HINT}`,
     );
   let capabilities: XcbCapabilities;
@@ -251,7 +253,7 @@ export async function selectProvider(
                     "<account>",
                     account.id,
                   )
-          }; run \`dawg login ${family === "xcb" ? "--xcb" : family}\``,
+          }; run \`dawg model key ${family === "xcb" ? "--xcb" : family}\``,
         );
     }
     // No saved pick: the first usable account, ready before admission pending.
@@ -274,7 +276,7 @@ export async function selectProvider(
   }
   return offline(
     explicit
-      ? `no ${FAMILY_NAMES[choice] ?? choice} is ready; run \`dawg login ${choice === "xcb" ? "--xcb" : choice}\``
+      ? `no ${FAMILY_NAMES[choice] ?? choice} is ready; run \`dawg model key ${choice === "xcb" ? "--xcb" : choice}\``
       : `no model configured; ${LOGIN_HINT}`,
   );
 }
@@ -349,12 +351,24 @@ export async function runProviderTurn(
     ...(options.signal ? { signal: options.signal } : {}),
     ...(options.budget ? { budget: options.budget } : {}),
   };
-  if (isApiSelection(selection))
+  if (isApiSelection(selection)) {
+    const model = options.model ?? selection.modelId;
+    const fallback = fallbackModelId(selection.kind, model);
+    if (options.host.commands && !options.model)
+      return runCommandAgentTurn({
+        ...common,
+        model,
+        ...(fallback ? { fallbackModel: fallback } : {}),
+        client: options.gatewayClient ?? apiClient(selection),
+        commands: options.host.commands,
+      });
     return runAgentTurn({
       ...common,
-      model: options.model ?? selection.modelId,
+      model,
+      ...(fallback ? { fallbackModel: fallback } : {}),
       client: options.gatewayClient ?? apiClient(selection),
     });
+  }
   if (selection.kind === "xcb") {
     const runner = options.runner ?? systemRunner;
     return runTextAgentTurn({

package/src/agent/range-tools.ts

@@ -0,0 +1,216 @@
+/**
+ * Agent tool for range edits (op1-ux §6.4): `edit_range` builds the same
+ * line the prompt runs (`loop 5-6`, `copy bass 5-6 to 7 x2`, `bars insert
+ * 2 at 3`, `section split chorus at 13`) and applies it through
+ * src/commands/range.ts or src/commands/arrange.ts, so the tool, the typed
+ * command and the menu agree. Its operations are the score diff.
+ *
+ * Bars count from 1, like the prompt and the bar ruler.
+ */
+import { diffScores } from "../../core/diff.ts";
+import { SCORE_LIMITS, type TrackScore } from "../../core/score.ts";
+import {
+  applySectionCommand,
+  loopSpan,
+  parseSectionCommand,
+} from "../commands/arrange.ts";
+import { parseLoopCommand } from "../commands/grammar.ts";
+import { applyRangeCommand, parseRangeCommand } from "../commands/range.ts";
+import type { AgentTool, ToolContext, ToolPlan } from "./tools.ts";
+import { ToolArgumentError } from "./tool-error.ts";
+
+export const RANGE_ACTIONS = [
+  "loop",
+  "unloop",
+  "copy",
+  "move",
+  "clear",
+  "reverse",
+  "insert_bars",
+  "remove_bars",
+  "split",
+  "join",
+] as const;
+
+type RangeAction = (typeof RANGE_ACTIONS)[number];
+
+const bar = (description: string) =>
+  ({
+    type: "integer",
+    minimum: 1,
+    maximum: SCORE_LIMITS.maxBars,
+    description,
+  }) as const;
+
+function whole(value: unknown, what: string, max: number): number {
+  if (
+    typeof value !== "number" ||
+    !Number.isInteger(value) ||
+    value < 1 ||
+    value > max
+  )
+    throw new ToolArgumentError(`${what} must be a whole number 1..${max}`);
+  return value;
+}
+
+function word(value: unknown, what: string): string {
+  if (typeof value !== "string" || !/^[\w .'-]{1,64}$/u.test(value.trim()))
+    throw new ToolArgumentError(`${what} must be a name`);
+  return value.trim();
+}
+
+/** `5-6`, `5`, or a section name: the range words of the typed command. */
+function rangeWords(args: Record<string, unknown>): string {
+  if (args.section !== undefined) return word(args.section, "section");
+  if (args.fromBar === undefined)
+    throw new ToolArgumentError("give fromBar (and toBar) or section");
+  const from = whole(args.fromBar, "fromBar", SCORE_LIMITS.maxBars);
+  const to =
+    args.toBar === undefined
+      ? from
+      : whole(args.toBar, "toBar", SCORE_LIMITS.maxBars);
+  if (to < from) throw new ToolArgumentError("toBar comes at or after fromBar");
+  return from === to ? `${from}` : `${from}-${to}`;
+}
+
+function trackWord(
+  args: Record<string, unknown>,
+  context: ToolContext,
+): string {
+  if (args.allTracks === true) return "all";
+  const id =
+    args.trackId === undefined
+      ? context.focusedTrackId
+      : word(args.trackId, "trackId");
+  if (!context.score.tracks.some((track) => track.id === id))
+    throw new ToolArgumentError(`no track ${id}`);
+  return id;
+}
+
+/** The typed command a call stands for (what show-me would type). */
+export function rangeToolCommand(
+  args: Record<string, unknown>,
+  context: ToolContext,
+): string {
+  const action = args.action as RangeAction;
+  if (!RANGE_ACTIONS.includes(action))
+    throw new ToolArgumentError(`action must be ${RANGE_ACTIONS.join(", ")}`);
+  switch (action) {
+    case "loop":
+      return `loop ${rangeWords(args)}`;
+    case "unloop":
+      return "loop off";
+    case "copy":
+    case "move": {
+      if (args.toBar === undefined && args.atBar === undefined)
+        throw new ToolArgumentError(`${action} needs atBar, where it lands`);
+      const at = whole(args.atBar, "atBar", SCORE_LIMITS.maxBars);
+      const times =
+        action === "copy" && args.times !== undefined
+          ? ` x${whole(args.times, "times", 64)}`
+          : "";
+      const mode =
+        args.insert === true
+          ? " insert"
+          : action === "copy" && args.merge === true
+            ? " merge"
+            : "";
+      return `${action} ${trackWord(args, context)} ${rangeWords(args)} to ${at}${times}${mode}`;
+    }
+    case "clear":
+    case "reverse":
+      return `${action} ${trackWord(args, context)} ${rangeWords(args)}`;
+    case "insert_bars":
+      return `bars insert ${whole(args.bars, "bars", SCORE_LIMITS.maxBars)} at ${whole(args.atBar, "atBar", SCORE_LIMITS.maxBars)}`;
+    case "remove_bars":
+      return `bars remove ${rangeWords(args)}`;
+    case "split":
+      return `section split ${word(args.section, "section")} at ${whole(args.atBar, "atBar", SCORE_LIMITS.maxBars)}`;
+    case "join":
+      return `section join ${word(args.section, "section")}`;
+  }
+}
+
+function run(
+  line: string,
+  context: ToolContext,
+): { next?: TrackScore; message: string } {
+  const score = context.score;
+  const loop = parseLoopCommand(line);
+  if (loop?.type === "loop-bars") {
+    const result = loopSpan(score, loop.from, loop.to);
+    if (!result.ok) throw new ToolArgumentError(result.message);
+    return { next: result.next, message: result.message };
+  }
+  if (loop?.type === "loop-off")
+    return score.loop
+      ? { next: score.withLoop(null), message: "loop · off · playing the song" }
+      : run("section loop off", context);
+  if (loop?.type === "loop-section")
+    return run(`section loop ${loop.name}`, context);
+  const range = parseRangeCommand(line, score);
+  if (range) {
+    const result = applyRangeCommand(
+      score,
+      { trackId: context.focusedTrackId, playheadBar: 0 },
+      range,
+    );
+    if (!result.ok) throw new ToolArgumentError(result.message);
+    return {
+      ...(result.next ? { next: result.next } : {}),
+      message: result.message,
+    };
+  }
+  const section = parseSectionCommand(line, score);
+  if (!section) throw new ToolArgumentError(`cannot run: ${line}`);
+  const result = applySectionCommand(score, context.focusedTrackId, section);
+  if (!result.ok) throw new ToolArgumentError(result.message);
+  return {
+    ...(result.next ? { next: result.next } : {}),
+    message: result.message,
+  };
+}
+
+export const RANGE_TOOLS: readonly AgentTool[] = Object.freeze([
+  {
+    name: "edit_range",
+    description:
+      "Edit bar ranges (bars count from 1; a range is fromBar..toBar or a section name). loop sets the loop range playback cycles (no section is made); unloop plays the song. copy copies a track's (or allTracks') notes, automation and clips in the range to atBar, overwriting there (merge keeps what is there; insert shifts later music right), times tiles it end to end. move is copy plus clearing the source. clear empties the range (the bars stay). reverse mirrors it in time. insert_bars adds `bars` empty bars at atBar and moves later sections, clips, automation and tempo points right; remove_bars cuts the range out. split cuts a section in two at atBar; join merges a section with the one after it. Each call is one undo step and runs the same command the prompt does.",
+    parameters: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: [...RANGE_ACTIONS] },
+        fromBar: bar("first bar of the range"),
+        toBar: bar("last bar of the range (default fromBar)"),
+        section: {
+          type: "string",
+          maxLength: 32,
+          description: "a section as the range (split/join: the section)",
+        },
+        atBar: bar("copy/move: where it lands; insert_bars/split: the bar"),
+        bars: bar("insert_bars: how many"),
+        times: { type: "integer", minimum: 1, maximum: 64 },
+        trackId: {
+          type: "string",
+          maxLength: SCORE_LIMITS.maxIdLength,
+          description: "the track (default: the focused track)",
+        },
+        allTracks: { type: "boolean" },
+        insert: { type: "boolean" },
+        merge: { type: "boolean" },
+      },
+      required: ["action"],
+      additionalProperties: false,
+    },
+    plan(args, context): ToolPlan {
+      const line = rangeToolCommand(args, context);
+      const result = run(line, context);
+      return {
+        kind: "score",
+        operations: result.next ? diffScores(context.score, result.next) : [],
+        trackId: context.focusedTrackId,
+        summary: result.message,
+      };
+    },
+  },
+]);

package/src/agent/rhythm-tools.ts

@@ -75,7 +75,7 @@ export const RHYTHM_TOOLS: readonly AgentTool[] = Object.freeze([
   {
     name: "set_rhythm",
     description:
-      "Preferred for drums: one row per voice of a kit/oneshot track; its notes regenerate from the row. pulses (4) over steps (16..64) Euclidean, rotate later; division 1/32..1/1 (1/16); grid 'x.X.' explicit (X accent); repeats 0..16 after each pulse every time, pace -1..1, ramp -1..1; velocity (0.8); accent 0..1 on E(accents,pulses); gate; legato; probability+seed; swing/nudge ±0.5 step; cycles [{pulses,rotate,repeats,probability,velocity}] per pass. remove [voices] (freeze keeps notes).",
+      "Preferred for drums: one row per voice of a kit/oneshot track; its notes regenerate from the row. pulses (4) over steps (16..64) Euclidean, rotate later; division 1/32..1/1 (1/16) is one step, and the steps×division cycle repeats from beat 0 to fill the loop (E(4,16) at 1/16 = a hit every beat, four on the floor; a backbeat on counts 2 and 4 is grid '....x.......x...' or E(2,16) rotate 4; offbeat 'and's are grid '..x.' ); grid 'x.X.' explicit (X accent); repeats 0..16 after each pulse every time, pace -1..1, ramp -1..1; velocity (0.8); accent 0..1 on E(accents,pulses); gate; legato; probability+seed; swing/nudge ±0.5 step; cycles [{pulses,rotate,repeats,probability,velocity}] per pass. remove [voices] (freeze keeps notes).",
     parameters: {
       type: "object",
       properties: {

package/src/agent/section-tools.ts

@@ -380,7 +380,7 @@ export const SECTION_TOOLS: readonly AgentTool[] = Object.freeze([
   },
   {
     name: "add_transition",
-    description: `Generate a transition with the built-in voices (bars count from 1). build: noise riser, accelerating snare roll, filter sweep and uplifter (all on by default), landing on the bar after its range. The range is \`bars\` bars (default 4) just before section \`into\` (the usual build into a drop or chorus); or a section's own bars (its last \`bars\` bars when bars is given); or \`bars\` bars starting at atBar; default the song's last 4 bars. The sweep is a high-pass up to 1.2 kHz on unfiltered or high-pass pitched tracks and a low-pass opening from cutoff/10 on low-pass tracks, on an octave curve, snapping back on the downbeat. drop: a pre-drop cut (cutBeats of silence, default 1, up to two bars) and an impact hit on the section's first bar or atBar (default: the section named drop, else chorus). fill: a drum fill (${FILL_STYLES.join(", ")}) in the last beats (default 1, ${FILL_BEATS_MIN} up to two bars) leading into the section or into atBar, plus a crash on its downbeat. Without section or atBar, fills go at every section boundary. Out-of-range values are clamped and the result says so.`,
+    description: `Generate a transition with the built-in voices (bars count from 1). build: noise riser, accelerating snare roll, filter sweep and uplifter (all on by default), landing on the bar after its range. The range is \`bars\` bars (default 4) just before section \`into\` (the usual build into a drop or chorus); or a section's own bars (its last \`bars\` bars when bars is given); or \`bars\` bars starting at atBar; default the song's last 4 bars. The sweep is a high-pass rising to 1.2 kHz on pitched tracks (a low-pass opening from cutoff/10 on low-pass tracks), snapping back on the downbeat. drop: a pre-drop cut (cutBeats of silence, default 1, up to two bars) and an impact hit on the section's first bar or atBar (default: the section named drop, else chorus). fill: a drum fill (${FILL_STYLES.join(", ")}) in the last beats (default 1, ${FILL_BEATS_MIN} up to two bars) leading into the section or into atBar, plus a crash on its downbeat. Without section or atBar, fills go at every section boundary. Out-of-range values are clamped.`,
     parameters: {
       type: "object",
       properties: {