@hraness/dawg 0.0.0-stage → 0.3.0

package/src/session/meta.ts

@@ -0,0 +1,253 @@
+/**
+ * Session metadata: the human name, who chose it, and fork lineage. It is
+ * stored inside the session record beside the composition, versioned on its
+ * own counter so renames never bump the score revision or the undo history.
+ */
+export const MAX_SESSION_NAME_LENGTH = 40;
+export const DEFAULT_SESSION_NAME = "untitled";
+const MAX_TIMESTAMP_LENGTH = 64;
+const MAX_ID_LENGTH = 64;
+const FINGERPRINT_PATTERN = /^[0-9a-f]{1,32}$/;
+/** C0/C1 controls, zero-width and bidi formatting characters. */
+const UNPRINTABLE = new RegExp(
+  "[\\u0000-\\u001f\\u007f-\\u009f\\u200b-\\u200f\\u2028-\\u202e\\u2066-\\u2069\\ufeff]",
+  "g",
+);
+const ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
+export type NameSource = "auto" | "user";
+
+export type SessionMeta = {
+  name: string;
+  /** `user` permanently stops auto-naming until `/rename --auto`. */
+  nameSource: NameSource;
+  forkOf?: { sessionId: string; revision: number };
+  createdAt: string;
+  updatedAt: string;
+  /** Incremented on every metadata write; independent of the score revision. */
+  version: number;
+  /** Fingerprint hash the current auto name was chosen for. */
+  namedFingerprint?: string;
+  /** Track-and-instrument-set hash at the last auto name. */
+  namedStructure?: string;
+};
+
+/** Fields a client may change. `null` clears an optional field. */
+export type MetaPatch = {
+  name?: string;
+  nameSource?: NameSource;
+  namedFingerprint?: string | null;
+  namedStructure?: string | null;
+};
+
+/** A conditional write applies only when every given field still matches. */
+export type MetaExpect = { name?: string; nameSource?: NameSource };
+
+export class MetaValidationError extends Error {
+  public constructor(message: string) {
+    super(message);
+    this.name = "MetaValidationError";
+  }
+}
+
+/** Trims, collapses whitespace, drops control characters, bounds to 40. */
+export function normalizeSessionName(value: unknown): string {
+  if (typeof value !== "string" || value.length > 1024)
+    throw new MetaValidationError("session name must be a short string");
+  const name = value
+    .replace(UNPRINTABLE, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, MAX_SESSION_NAME_LENGTH)
+    .trim();
+  if (name.length === 0) throw new MetaValidationError("session name is empty");
+  return name;
+}
+
+export function defaultSessionMeta(
+  at: string,
+  name = DEFAULT_SESSION_NAME,
+): SessionMeta {
+  return {
+    name,
+    nameSource: "auto",
+    createdAt: at,
+    updatedAt: at,
+    version: 0,
+  };
+}
+
+/**
+ * Validates metadata read from disk or the wire. Records written before
+ * metadata existed get a deterministic name derived from their id.
+ */
+export function parseSessionMeta(
+  value: unknown,
+  fallback: { sessionId: string; updatedAt: string },
+): SessionMeta {
+  if (value === undefined || value === null)
+    return defaultSessionMeta(
+      fallback.updatedAt,
+      `session ${fallback.sessionId.slice(0, 8)}`,
+    );
+  if (typeof value !== "object" || Array.isArray(value))
+    throw new MetaValidationError("session meta must be an object");
+  const meta = value as Record<string, unknown>;
+  const nameSource = meta.nameSource;
+  if (nameSource !== "auto" && nameSource !== "user")
+    throw new MetaValidationError("session nameSource is invalid");
+  if (!Number.isSafeInteger(meta.version) || (meta.version as number) < 0)
+    throw new MetaValidationError("session meta version is invalid");
+  const result: SessionMeta = {
+    name: normalizeSessionName(meta.name),
+    nameSource,
+    createdAt: timestamp(meta.createdAt, "createdAt"),
+    updatedAt: timestamp(meta.updatedAt, "updatedAt"),
+    version: meta.version as number,
+  };
+  if (meta.forkOf !== undefined) {
+    const fork = meta.forkOf;
+    if (typeof fork !== "object" || fork === null)
+      throw new MetaValidationError("session forkOf is invalid");
+    const { sessionId, revision } = fork as Record<string, unknown>;
+    if (
+      typeof sessionId !== "string" ||
+      sessionId.length === 0 ||
+      sessionId.length > MAX_ID_LENGTH ||
+      !ID_PATTERN.test(sessionId) ||
+      !Number.isSafeInteger(revision) ||
+      (revision as number) < 0
+    )
+      throw new MetaValidationError("session forkOf is invalid");
+    result.forkOf = { sessionId, revision: revision as number };
+  }
+  const fingerprint = optionalFingerprint(meta.namedFingerprint);
+  if (fingerprint) result.namedFingerprint = fingerprint;
+  const structure = optionalFingerprint(meta.namedStructure);
+  if (structure) result.namedStructure = structure;
+  return result;
+}
+
+/** Validates a client patch from `unknown`; unknown keys are ignored. */
+export function parseMetaPatch(value: unknown): MetaPatch {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new MetaValidationError("meta patch must be an object");
+  const raw = value as Record<string, unknown>;
+  const patch: MetaPatch = {};
+  if (raw.name !== undefined) patch.name = normalizeSessionName(raw.name);
+  if (raw.nameSource !== undefined) {
+    if (raw.nameSource !== "auto" && raw.nameSource !== "user")
+      throw new MetaValidationError("nameSource is invalid");
+    patch.nameSource = raw.nameSource;
+  }
+  for (const key of ["namedFingerprint", "namedStructure"] as const) {
+    if (raw[key] === undefined) continue;
+    patch[key] = raw[key] === null ? null : requireFingerprint(raw[key]);
+  }
+  if (Object.keys(patch).length === 0)
+    throw new MetaValidationError("meta patch is empty");
+  return patch;
+}
+
+export function parseMetaExpect(value: unknown): MetaExpect | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value !== "object" || Array.isArray(value))
+    throw new MetaValidationError("meta condition must be an object");
+  const raw = value as Record<string, unknown>;
+  const expect: MetaExpect = {};
+  if (raw.name !== undefined) expect.name = normalizeSessionName(raw.name);
+  if (raw.nameSource !== undefined) {
+    if (raw.nameSource !== "auto" && raw.nameSource !== "user")
+      throw new MetaValidationError("nameSource is invalid");
+    expect.nameSource = raw.nameSource;
+  }
+  return expect;
+}
+
+export function metaMatches(meta: SessionMeta, expect?: MetaExpect): boolean {
+  if (!expect) return true;
+  if (expect.name !== undefined && expect.name !== meta.name) return false;
+  if (expect.nameSource !== undefined && expect.nameSource !== meta.nameSource)
+    return false;
+  return true;
+}
+
+export function applyMetaPatch(
+  meta: SessionMeta,
+  patch: MetaPatch,
+  at: string,
+): SessionMeta {
+  const next: SessionMeta = {
+    ...meta,
+    updatedAt: at,
+    version: meta.version + 1,
+  };
+  if (patch.name !== undefined) next.name = patch.name;
+  if (patch.nameSource !== undefined) next.nameSource = patch.nameSource;
+  for (const key of ["namedFingerprint", "namedStructure"] as const) {
+    if (patch[key] === null) delete next[key];
+    else if (patch[key] !== undefined) next[key] = patch[key];
+  }
+  return next;
+}
+
+/** Splits a trailing ` N` (N ≥ 2) suffix: `x 3` → `{ base: "x", n: 3 }`. */
+export function splitNameNumber(name: string): { base: string; n: number } {
+  const match = name.match(/^(.*\S) (\d{1,4})$/);
+  if (!match) return { base: name, n: 1 };
+  const n = Number(match[2]);
+  return n >= 2 ? { base: match[1]!, n } : { base: name, n: 1 };
+}
+
+/**
+ * Default fork name: strip any trailing ` N` from the parent, then take the
+ * highest ` N` among sessions with that base, plus one (`x` → `x 2` → `x 3`;
+ * a fork of `x 2` is `x 3` too).
+ */
+export function forkName(parent: string, existing: readonly string[]): string {
+  const { base } = splitNameNumber(parent);
+  let highest = 1;
+  for (const name of existing) {
+    const split = splitNameNumber(name);
+    if (split.base === base) highest = Math.max(highest, split.n);
+  }
+  return withNumber(base, highest + 1);
+}
+
+/** Adds or bumps a ` N` suffix until the name is not in `taken`. */
+export function uniqueName(name: string, taken: readonly string[]): string {
+  const lower = new Set(taken.map((entry) => entry.toLowerCase()));
+  if (!lower.has(name.toLowerCase())) return name;
+  const { base, n } = splitNameNumber(name);
+  for (let next = Math.max(2, n + 1); next < 10_000; next += 1) {
+    const candidate = withNumber(base, next);
+    if (!lower.has(candidate.toLowerCase())) return candidate;
+  }
+  return name;
+}
+
+export function withNumber(base: string, n: number): string {
+  const suffix = ` ${n}`;
+  return `${base.slice(0, MAX_SESSION_NAME_LENGTH - suffix.length).trimEnd()}${suffix}`;
+}
+
+function timestamp(value: unknown, label: string): string {
+  if (
+    typeof value !== "string" ||
+    value.length === 0 ||
+    value.length > MAX_TIMESTAMP_LENGTH
+  )
+    throw new MetaValidationError(`session ${label} is invalid`);
+  return value;
+}
+
+function optionalFingerprint(value: unknown): string | undefined {
+  if (value === undefined || value === null) return undefined;
+  return requireFingerprint(value);
+}
+
+function requireFingerprint(value: unknown): string {
+  if (typeof value !== "string" || !FINGERPRINT_PATTERN.test(value))
+    throw new MetaValidationError("fingerprint is invalid");
+  return value;
+}

package/src/session/naming.ts

@@ -0,0 +1,430 @@
+/**
+ * Token-efficient session auto-naming.
+ *
+ * Every accepted turn updates a local *musical fingerprint* (tempo, a key
+ * estimate from the pitch-class histogram, each track's role and instrument,
+ * note density, register, and effects). A model call happens only when that
+ * fingerprint differs from the one the current name was chosen for, and at
+ * most every `minTurns` turns unless the track or instrument set changed.
+ * The request is ~120 tokens in and 12 out, asks the model to echo the
+ * current name when it still fits (hysteresis), and is applied as a
+ * conditional write so a user `/rename` always wins.
+ */
+import { createHash } from "node:crypto";
+import type { TrackScore } from "../../core/score.ts";
+import { isDrumInstrument } from "../../core/drums.ts";
+import { estimateKey } from "../../core/key.ts";
+
+export { estimateKey };
+import type { ProviderSelection } from "../agent/provider.ts";
+import {
+  DEFAULT_SESSION_NAME,
+  splitNameNumber,
+  uniqueName,
+  withNumber,
+  type MetaExpect,
+  type MetaPatch,
+  type SessionMeta,
+} from "./meta.ts";
+
+export const NAME_MAX_TOKENS = 12;
+export const NAME_TEMPERATURE = 0.3;
+const PROMPT_SNIPPET_CHARS = 60;
+
+export type TrackRole = "drums" | "bass" | "keys" | "lead";
+
+export type Fingerprint = {
+  /** Human-readable summary sent to the model. */
+  line: string;
+  /** Hash of `line`; equal scores always hash equally. */
+  hash: string;
+  /** Hash of the track-and-instrument set only. */
+  structure: string;
+  bpm: number;
+  key: string | null;
+  roles: TrackRole[];
+  busy: boolean;
+};
+
+/**
+ * Pure and order-independent: note ids, note order and track names do not
+ * affect it, so the same music always yields the same hash.
+ */
+export function musicalFingerprint(score: TrackScore): Fingerprint {
+  const bpm = Math.round(score.tempoBpm);
+  const bars = Math.max(1, score.bars);
+  const histogram = new Array<number>(12).fill(0);
+  const parts: string[] = [];
+  const roles: TrackRole[] = [];
+  const effects = new Set<string>();
+  let busy = false;
+  const tracks = [...score.tracks].sort((a, b) => a.id.localeCompare(b.id));
+  for (const track of tracks) {
+    const notes = score.notes.filter((note) => note.trackId === track.id);
+    const drums = isDrumInstrument(track.instrument);
+    if (!drums)
+      for (const note of notes)
+        histogram[note.pitch % 12]! += note.durationTicks / score.ticksPerBeat;
+    const perBar = notes.length / bars;
+    const density =
+      notes.length === 0
+        ? "empty"
+        : perBar < 2
+          ? "sparse"
+          : perBar < 6
+            ? "steady"
+            : "busy";
+    if (density === "busy") busy = true;
+    const pitches = notes.map((note) => note.pitch).sort((a, b) => a - b);
+    const median = pitches.length ? pitches[pitches.length >> 1]! : 60;
+    const register = median < 48 ? "low" : median <= 72 ? "mid" : "high";
+    const role: TrackRole = drums
+      ? "drums"
+      : register === "low"
+        ? "bass"
+        : register === "high"
+          ? "lead"
+          : "keys";
+    if (notes.length > 0) roles.push(role);
+    if (track.filter) effects.add("filter");
+    if (track.delay) effects.add("delay");
+    if (track.reverb) effects.add("reverb");
+    if (track.volumeAutomation.length || track.panAutomation.length)
+      effects.add("automation");
+    if (
+      track.filterAutomation?.length ||
+      track.resonanceAutomation?.length ||
+      track.delayFeedbackAutomation?.length ||
+      track.delayMixAutomation?.length
+    )
+      effects.add("sweep");
+    const instrument = track.instrument.toLowerCase().slice(0, 24);
+    parts.push(
+      drums
+        ? `drums(${instrument},${density})`
+        : `${role}(${instrument},${register},${density})`,
+    );
+  }
+  const key = score.key ? score.key.toLowerCase() : estimateKey(histogram);
+  const line = [
+    `${bpm} bpm`,
+    key ?? "no key",
+    parts.join(" ") || "no tracks",
+    effects.size ? `fx ${[...effects].sort().join(" ")}` : "",
+  ]
+    .filter(Boolean)
+    .join(" · ");
+  const structure = tracks
+    .map((track) => `${track.id}=${track.instrument.toLowerCase()}`)
+    .join(",");
+  return {
+    line,
+    hash: shortHash(line),
+    structure: shortHash(structure),
+    bpm,
+    key,
+    roles: [...new Set(roles)],
+    busy,
+  };
+}
+
+/** Deterministic offline name, e.g. "a minor bass groove" or "128 bpm drums + keys". */
+export function localName(fingerprint: Fingerprint): string {
+  const roles = fingerprint.roles;
+  if (roles.length === 0) return DEFAULT_SESSION_NAME;
+  const pitched = roles.filter((role) => role !== "drums");
+  if (fingerprint.key && pitched.length > 0) {
+    const lead = pitched.includes("bass") ? "bass" : pitched[0]!;
+    const vibe =
+      roles.includes("drums") || fingerprint.busy ? "groove" : "loop";
+    return `${fingerprint.key} ${lead} ${vibe}`;
+  }
+  return `${fingerprint.bpm} bpm ${roles.join(" + ")}`;
+}
+
+/**
+ * Validates untrusted model output: lowercase, only `[a-z0-9 '-]`, 3 to 32
+ * characters, at most 4 words. Returns undefined when it does not fit.
+ */
+export function sanitizeGeneratedName(text: unknown): string | undefined {
+  if (typeof text !== "string") return undefined;
+  const firstLine = text.slice(0, 256).split(/\r?\n/)[0] ?? "";
+  const name = firstLine
+    .toLowerCase()
+    .replace(/^name\s*:\s*/, "")
+    .replace(/[^a-z0-9 '-]/g, " ")
+    .replace(/\s+/g, " ")
+    .replace(/^['\s-]+|['\s-]+$/g, "")
+    .trim();
+  if (name.length < 3 || name.length > 32) return undefined;
+  if (name.split(" ").length > 4) return undefined;
+  return name;
+}
+
+export function namingPrompt(
+  fingerprint: Fingerprint,
+  recentPrompts: readonly string[],
+  currentName: string,
+): string {
+  const recent = recentPrompts
+    .slice(-2)
+    .map((prompt) => {
+      const flat = prompt.replace(/\s+/g, " ").trim();
+      return `"${flat.length > PROMPT_SNIPPET_CHARS ? flat.slice(0, PROMPT_SNIPPET_CHARS) : flat}"`;
+    })
+    .join(" | ");
+  return [
+    "Name this music session: 2-4 lowercase words evoking the vibe; reply with the current name exactly if it still fits; no quotes.",
+    `music: ${fingerprint.line}`,
+    `recent: ${recent || "none"}`,
+    `current name: ${currentName === DEFAULT_SESSION_NAME ? "none" : currentName}`,
+  ].join("\n");
+}
+
+/** The model seam. Implementations must not throw synchronously. */
+export interface NameGenerator {
+  generate(
+    prompt: string,
+    options: { maxTokens: number; temperature: number; signal: AbortSignal },
+  ): Promise<string>;
+}
+
+/**
+ * Default generator: `generateText` on the configured provider (gateway
+ * haiku-4.5 or the selected xcb account). It throws when offline, which the
+ * namer turns into the local fingerprint name. `generateText` has no
+ * temperature knob, so `temperature` is advisory here.
+ */
+export function providerNameGenerator(
+  selection: () => Promise<ProviderSelection>,
+  timeoutMs = 15_000,
+): NameGenerator {
+  return {
+    async generate(prompt, options) {
+      const selected = await selection();
+      if (selected.kind === "offline") throw new Error(selected.reason);
+      const { generateText } = await import("../agent/provider.ts");
+      return generateText(prompt, {
+        maxTokens: options.maxTokens,
+        signal: options.signal,
+        timeoutMs,
+        selection: selected,
+      });
+    },
+  };
+}
+
+/** Where the namer reads and conditionally writes session metadata. */
+export interface NamingTarget {
+  meta(): SessionMeta;
+  updateMeta(
+    patch: MetaPatch,
+    expect: MetaExpect,
+  ): Promise<{ status: "applied" | "stale"; meta: SessionMeta }>;
+  /** Names of other sessions in the workspace, for collision suffixes. */
+  otherNames(): Promise<string[]>;
+}
+
+export type AutoNamerOptions = {
+  target: NamingTarget;
+  /** Omit for offline: names come from the local fingerprint only. */
+  generator?: NameGenerator | undefined;
+  delayMs?: number;
+  minTurns?: number;
+  timeoutMs?: number;
+  onRename?: (name: string, source: "model" | "local") => void;
+};
+
+export type NamerStats = {
+  /** Model requests issued. */
+  calls: number;
+  /** Runs that wrote a name (model or local). */
+  renames: number;
+  /** Runs skipped because the fingerprint was unchanged. */
+  unchanged: number;
+  /** Runs deferred by the every-N-turns limit. */
+  deferred: number;
+  /** In-flight results dropped because the name changed meanwhile. */
+  dropped: number;
+};
+
+/**
+ * Debounced, single-flight auto-namer. `noteTurn` is synchronous and never
+ * blocks the prompt; work happens on a timer.
+ */
+export class AutoNamer {
+  public readonly stats: NamerStats = {
+    calls: 0,
+    renames: 0,
+    unchanged: 0,
+    deferred: 0,
+    dropped: 0,
+  };
+  private readonly delayMs: number;
+  private readonly minTurns: number;
+  private readonly timeoutMs: number;
+  private readonly recent: string[] = [];
+  private score: TrackScore | undefined;
+  private turnsSinceName = 0;
+  private timer: ReturnType<typeof setTimeout> | undefined;
+  private running: Promise<void> | undefined;
+  private rerun = false;
+  private disposed = false;
+  private readonly controller = new AbortController();
+
+  public constructor(private readonly options: AutoNamerOptions) {
+    this.delayMs = options.delayMs ?? 3_000;
+    this.minTurns = Math.max(1, options.minTurns ?? 3);
+    this.timeoutMs = options.timeoutMs ?? 20_000;
+  }
+
+  /** Call after a turn; `accepted` is false when it committed nothing. */
+  public noteTurn(turn: {
+    score: TrackScore;
+    prompt: string;
+    accepted: boolean;
+  }): void {
+    if (this.disposed || !turn.accepted) return;
+    this.recent.push(turn.prompt.slice(0, 256));
+    if (this.recent.length > 2) this.recent.shift();
+    this.score = turn.score;
+    this.turnsSinceName += 1;
+    if (this.options.target.meta().nameSource !== "auto") return;
+    // Coalesce bursts: each accepted turn restarts the quiet period.
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = undefined;
+      void this.kick();
+    }, this.delayMs);
+    this.timer.unref?.();
+  }
+
+  /** After `/rename --auto`: name soon from `score`, bypassing the turn limit. */
+  public request(score: TrackScore): void {
+    if (this.disposed) return;
+    this.score = score;
+    this.turnsSinceName = this.minTurns;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = undefined;
+      void this.kick();
+    }, this.delayMs);
+    this.timer.unref?.();
+  }
+
+  /** Resolves when no run is pending or in flight (for tests and exit). */
+  public async idle(): Promise<void> {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = undefined;
+      await this.kick();
+    }
+    while (this.running) await this.running;
+  }
+
+  public dispose(): void {
+    this.disposed = true;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = undefined;
+    this.controller.abort();
+  }
+
+  private kick(): Promise<void> {
+    if (this.running) {
+      // At most one request in flight; fold this trigger into a rerun.
+      this.rerun = true;
+      return this.running;
+    }
+    this.running = this.run()
+      .catch(() => undefined)
+      .finally(() => {
+        this.running = undefined;
+        if (this.rerun && !this.disposed) {
+          this.rerun = false;
+          void this.kick();
+        }
+      });
+    return this.running;
+  }
+
+  private async run(): Promise<void> {
+    const score = this.score;
+    if (!score || this.disposed) return;
+    const meta = this.options.target.meta();
+    if (meta.nameSource !== "auto") return;
+    const fingerprint = musicalFingerprint(score);
+    if (fingerprint.hash === meta.namedFingerprint) {
+      this.stats.unchanged += 1;
+      return;
+    }
+    const structureChanged = fingerprint.structure !== meta.namedStructure;
+    if (
+      meta.namedFingerprint !== undefined &&
+      !structureChanged &&
+      this.turnsSinceName < this.minTurns
+    ) {
+      this.stats.deferred += 1;
+      return;
+    }
+    // Forks keep their ` N` suffix; the model sees only the base.
+    const split = meta.forkOf ? splitNameNumber(meta.name) : undefined;
+    const currentBase = split && split.n > 1 ? split.base : meta.name;
+    let candidate: string | undefined;
+    let source: "model" | "local" = "local";
+    if (this.options.generator) {
+      this.stats.calls += 1;
+      try {
+        const signal = AbortSignal.any([
+          this.controller.signal,
+          AbortSignal.timeout(this.timeoutMs),
+        ]);
+        const text = await this.options.generator.generate(
+          namingPrompt(fingerprint, this.recent, currentBase),
+          {
+            maxTokens: NAME_MAX_TOKENS,
+            temperature: NAME_TEMPERATURE,
+            signal,
+          },
+        );
+        candidate = sanitizeGeneratedName(text);
+        if (candidate) source = "model";
+      } catch {
+        // Offline, unauthorized, timed out: fall back to the local name.
+      }
+    }
+    if (this.disposed) return;
+    candidate ??= localName(fingerprint);
+    let name =
+      candidate === currentBase
+        ? meta.name
+        : split && split.n > 1
+          ? withNumber(candidate, split.n)
+          : candidate;
+    if (name !== meta.name) {
+      const others = await this.options.target.otherNames().catch(() => []);
+      name = uniqueName(name, others);
+    }
+    const patch: MetaPatch = {
+      namedFingerprint: fingerprint.hash,
+      namedStructure: fingerprint.structure,
+    };
+    if (name !== meta.name) patch.name = name;
+    const result = await this.options.target.updateMeta(patch, {
+      name: meta.name,
+      nameSource: "auto",
+    });
+    if (result.status === "stale") {
+      this.stats.dropped += 1;
+      return;
+    }
+    this.turnsSinceName = 0;
+    if (patch.name !== undefined) {
+      this.stats.renames += 1;
+      this.options.onRename?.(patch.name, source);
+    }
+  }
+}
+
+function shortHash(text: string): string {
+  return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}