fluncle 0.219.0 → 0.221.0

package/bin/fluncle.mjs

@@ -610,7 +610,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.219.0".trim() ? "0.219.0".trim() : "0.1.0";
+  currentVersion = "0.221.0".trim() ? "0.221.0".trim() : "0.1.0";
 });
 
 // src/update-notifier.ts
@@ -2452,7 +2452,7 @@ function parseVersion2(version) {
 var currentVersion2, latestReleaseUrl = "https://api.github.com/repos/mauricekleine/fluncle/releases/latest";
 var init_version2 = __esm(() => {
   init_output();
-  currentVersion2 = "0.219.0".trim() ? "0.219.0".trim() : "0.1.0";
+  currentVersion2 = "0.221.0".trim() ? "0.221.0".trim() : "0.1.0";
 });
 
 // ../../packages/registry/src/index.ts
@@ -4934,11 +4934,14 @@ async function backfillAppleCatalogueCommand(limit, dryRun) {
   const params = new URLSearchParams({ dryRun: String(dryRun), limit: String(limit) });
   return adminApiPost(`/api/v1/admin/backfill/apple-catalogue?${params.toString()}`);
 }
-async function backfillRecordingMbidsCommand(limit, dryRun, cursor) {
+async function backfillRecordingMbidsCommand(limit, dryRun, cursor, isrcRefreshLimit) {
   const params = new URLSearchParams({ dryRun: String(dryRun), limit: String(limit) });
   if (cursor) {
     params.set("cursor", cursor);
   }
+  if (isrcRefreshLimit !== undefined) {
+    params.set("isrcRefreshLimit", String(isrcRefreshLimit));
+  }
   return adminApiPost(`/api/v1/admin/backfill/recording-mbids?${params.toString()}`);
 }
 async function backfillArtistEdgesCommand(limit, dryRun, cursor) {
@@ -7016,15 +7019,48 @@ var init_admin_reach = __esm(() => {
 var exports_admin_artists = {};
 __export(exports_admin_artists, {
   resolveArtistCommand: () => resolveArtistCommand,
+  removeArtistRuleCommand: () => removeArtistRuleCommand,
   rankArtistsCommand: () => rankArtistsCommand,
   listArtistsCommand: () => listArtistsCommand,
+  listArtistRulesCommand: () => listArtistRulesCommand,
   draftArtistBioCommand: () => draftArtistBioCommand,
   describeArtistCommand: () => describeArtistCommand,
   buildBioBody: () => buildBioBody,
   backfillArtistsCommand: () => backfillArtistsCommand,
   backfillArtistImagesCommand: () => backfillArtistImagesCommand,
-  artistsBioQueueCommand: () => artistsBioQueueCommand
+  artistsBioQueueCommand: () => artistsBioQueueCommand,
+  artistRuleInput: () => artistRuleInput,
+  addArtistRuleCommand: () => addArtistRuleCommand
 });
+function artistRuleInput(artistMbid, verdict, artistName) {
+  const cleanMbid = artistMbid.trim();
+  if (!MBID_PATTERN.test(cleanMbid)) {
+    throw new Error("Artist MBID must be a MusicBrainz artist MBID");
+  }
+  if (verdict !== "allow" && verdict !== "block") {
+    throw new Error("Pass --verdict allow|block");
+  }
+  const cleanName = artistName?.trim();
+  if (artistName !== undefined && !cleanName) {
+    throw new Error("--name must be a non-empty artist name");
+  }
+  return {
+    artistMbid: cleanMbid.toLowerCase(),
+    ...cleanName ? { artistName: cleanName } : {},
+    verdict
+  };
+}
+async function listArtistRulesCommand() {
+  const response = await adminApiGet("/api/v1/admin/artist-rules");
+  return response.rules;
+}
+async function addArtistRuleCommand(input) {
+  const response = await adminApiPost("/api/v1/admin/artist-rules", input);
+  return response.rule;
+}
+async function removeArtistRuleCommand(id) {
+  return adminApiDelete(`/api/v1/admin/artist-rules/${encodeURIComponent(id)}`);
+}
 function buildBioBody(options) {
   const body = { bio: options.bio };
   if (options.dryRun) {
@@ -7077,8 +7113,10 @@ async function backfillArtistsCommand(limit, dryRun, cursor) {
   }
   return adminApiPost(`/api/v1/admin/backfill/artists?${params.toString()}`);
 }
+var MBID_PATTERN;
 var init_admin_artists = __esm(() => {
   init_api();
+  MBID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 });
 
 // src/commands/admin-artists.ts
@@ -7103,23 +7141,84 @@ var init_admin_artists2 = __esm(() => {
 var exports_admin_labels = {};
 __export(exports_admin_labels, {
   updateLabelCommand: () => updateLabelCommand,
+  replaceLabelArtistRulesCommand: () => replaceLabelArtistRulesCommand,
+  parseLabelArtistRulesJson: () => parseLabelArtistRulesJson,
   mergeLabelCommand: () => mergeLabelCommand,
+  listLabelArtistRulesCommand: () => listLabelArtistRulesCommand,
   labelsBioQueueCommand: () => labelsBioQueueCommand,
   draftLabelBioCommand: () => draftLabelBioCommand,
   describeLabelCommand: () => describeLabelCommand,
   backfillLabelLineageCommand: () => backfillLabelLineageCommand,
   backfillLabelImagesCommand: () => backfillLabelImagesCommand
 });
-async function mergeLabelCommand(losingSlug, canonicalSlug) {
-  const response = await adminApiPost(`/api/v1/admin/labels/${encodeURIComponent(losingSlug)}/merge`, { canonicalSlug });
-  return response.result;
+function requireArtistMbid(value, at) {
+  if (typeof value !== "string" || !MBID_PATTERN2.test(value.trim())) {
+    throw new Error(`${at}.artistMbid must be a MusicBrainz artist MBID`);
+  }
+  return value.trim().toLowerCase();
 }
-async function updateLabelCommand(slugOrId, seedState, rewalk = false) {
+function requireArtistName(value, at) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${at}.artistName must be a non-empty string`);
+  }
+  return value.trim();
+}
+function requireArtistVerdict(value, at) {
+  if (value === "allow" || value === "block") {
+    return value;
+  }
+  throw new Error(`${at}.verdict must be 'allow' or 'block'`);
+}
+function parseLabelArtistRulesJson(source) {
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch {
+    throw new Error("Rules file must contain valid JSON");
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error("Rules file must contain a JSON array");
+  }
+  if (parsed.length > 100) {
+    throw new Error("Rules file may contain at most 100 artist rules");
+  }
+  return parsed.map((entry, index) => {
+    const at = `Rules file entry ${index + 1}`;
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      throw new Error(`${at} must be an object`);
+    }
+    const value = entry;
+    return {
+      artistMbid: requireArtistMbid(value.artistMbid, at),
+      artistName: requireArtistName(value.artistName, at),
+      verdict: requireArtistVerdict(value.verdict, at)
+    };
+  });
+}
+async function resolveLabel(slugOrId) {
   const { labels } = await adminApiGet("/api/v1/admin/labels");
   const match = labels.find((label) => label.slug === slugOrId || label.id === slugOrId);
   if (!match) {
     throw new Error(`No label with slug or id '${slugOrId}' — check \`fluncle labels\``);
   }
+  return match;
+}
+async function listLabelArtistRulesCommand(slugOrId) {
+  const label = await resolveLabel(slugOrId);
+  const response = await adminApiGet(`/api/v1/admin/labels/${encodeURIComponent(label.id)}/artists`);
+  return { label, rules: response.rules };
+}
+async function replaceLabelArtistRulesCommand(slugOrId, rules) {
+  const label = await resolveLabel(slugOrId);
+  const response = await adminApiPut(`/api/v1/admin/labels/${encodeURIComponent(label.id)}/artists`, { rules });
+  return { label, rules: response.rules };
+}
+async function mergeLabelCommand(losingSlug, canonicalSlug) {
+  const response = await adminApiPost(`/api/v1/admin/labels/${encodeURIComponent(losingSlug)}/merge`, { canonicalSlug });
+  return response.result;
+}
+async function updateLabelCommand(slugOrId, seedState, rewalk = false) {
+  const match = await resolveLabel(slugOrId);
   const response = await adminApiPatch(`/api/v1/admin/labels/${encodeURIComponent(match.id)}`, {
     ...rewalk ? { rewalk: true } : {},
     ...seedState === undefined ? {} : { seedState }
@@ -7150,9 +7249,11 @@ async function backfillLabelLineageCommand(limit, dryRun, cursor) {
   }
   return adminApiPost(`/api/v1/admin/backfill/label-lineage?${params.toString()}`);
 }
+var MBID_PATTERN2;
 var init_admin_labels = __esm(() => {
   init_api();
   init_admin_artists2();
+  MBID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 });
 
 // src/commands/admin-covers.ts
@@ -9693,6 +9794,26 @@ function labelUpdateLines(label, options) {
   }
   return lines;
 }
+var ARTIST_RULE_BOUNDARY = "Rules change what the next crawl takes. Everything already here stays.";
+function artistRuleWriteLine(prefix) {
+  return `${prefix} \u2014 ${ARTIST_RULE_BOUNDARY.replace(/^R/, "r")}`;
+}
+function artistRuleLines(rules) {
+  if (rules.length === 0) {
+    return ["No artist rules."];
+  }
+  const rows = rules.map((rule) => [
+    rule.id,
+    rule.verdict,
+    rule.resolvedName ?? rule.artistName,
+    rule.resolvedMbid ?? rule.artistMbid,
+    rule.artistSpotifyId ?? "unresolved"
+  ]);
+  const headings = ["ID", "VERDICT", "ARTIST", "MUSICBRAINZ", "SPOTIFY"];
+  const widths = headings.map((heading, index) => Math.max(heading.length, ...rows.map((row) => row[index]?.length ?? 0)));
+  const line = (row) => row.map((value, index) => value.padEnd(widths[index] ?? value.length)).join("  ").trimEnd();
+  return [line(headings), line(widths.map((width) => "-".repeat(width))), ...rows.map(line)];
+}
 function createProgram() {
   const program2 = configureCommand(new Command);
   program2.name("fluncle").description(fluncleTagline.toLowerCase()).option("--env <local|production>", "Config profile to load (default: production)").showSuggestionAfterError(false).addHelpCommand("help [command]", "display help for command").hook("preAction", (_thisCommand, actionCommand) => {
@@ -10548,7 +10669,7 @@ JSON field reference:
     const { backfillLabelLineageCommand: backfillLabelLineageCommand2 } = await Promise.resolve().then(() => (init_admin_labels(), exports_admin_labels));
     await runBackfillLabelLineage(options, backfillLabelLineageCommand2);
   });
-  backfill.command("recording-mbids").description("Fill MusicBrainz recording MBIDs (crawler PK strip + ISRC resolve) over tracks").option("--dry-run", "Report the eligible worklist without any vendor call or write", false).option("--limit <limit>", "Max ISRC lookups to process", "50").option("--json", "Print JSON", false).action(async (options) => {
+  backfill.command("recording-mbids").description("Fill MusicBrainz recording MBIDs (crawler PK strip + ISRC resolve) over tracks").option("--dry-run", "Report the eligible worklist without any vendor call or write", false).option("--limit <limit>", "Max ISRC lookups to process", "50").option("--isrc-refresh-limit <limit>", "Max MusicBrainz ISRC re-reads to process", "25").option("--json", "Print JSON", false).action(async (options) => {
     const { backfillRecordingMbidsCommand: backfillRecordingMbidsCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
     await runBackfillRecordingMbids(options, backfillRecordingMbidsCommand2);
   });
@@ -10586,6 +10707,34 @@ JSON field reference:
     const { rankArtistsCommand: rankArtistsCommand2 } = await Promise.resolve().then(() => (init_admin_artists(), exports_admin_artists));
     await runArtistsRank(options, rankArtistsCommand2);
   });
+  artists.command("rule").description("Always or never take one MusicBrainz artist's records (operator)").argument("<artist-mbid>", "The MusicBrainz artist MBID").requiredOption("--verdict <verdict>", "The ruling: allow or block").option("--name <name>", "Artist name (optional; the server resolves it when omitted)").option("--json", "Print JSON", false).action(async (artistMbid, options) => {
+    const { addArtistRuleCommand: addArtistRuleCommand2, artistRuleInput: artistRuleInput2 } = await Promise.resolve().then(() => (init_admin_artists(), exports_admin_artists));
+    const rule = await addArtistRuleCommand2(artistRuleInput2(artistMbid, options.verdict, options.name));
+    if (options.json) {
+      printJson({ ok: true, rule });
+      return;
+    }
+    console.log(artistRuleWriteLine(`Rule set for ${rule.resolvedName ?? rule.artistName}: ${rule.verdict.toUpperCase()}`));
+  });
+  artists.command("rules").description("List the global artist crawl rules").option("--json", "Print JSON", false).action(async (options) => {
+    const { listArtistRulesCommand: listArtistRulesCommand2 } = await Promise.resolve().then(() => (init_admin_artists(), exports_admin_artists));
+    const rules = await listArtistRulesCommand2();
+    if (options.json) {
+      printJson({ ok: true, rules });
+      return;
+    }
+    console.log(artistRuleLines(rules).join(`
+`));
+  });
+  artists.command("unrule").description("Remove one global artist crawl rule (operator)").argument("<id>", "The artist rule id").option("--json", "Print JSON", false).action(async (id, options) => {
+    const { removeArtistRuleCommand: removeArtistRuleCommand2 } = await Promise.resolve().then(() => (init_admin_artists(), exports_admin_artists));
+    const result = await removeArtistRuleCommand2(id);
+    if (options.json) {
+      printJson(result);
+      return;
+    }
+    console.log(artistRuleWriteLine(`Rule removed: ${id}`));
+  });
   artists.command("draft-bio").description("Assemble the Worker-grounded bio prompt for an artist (the sweep's trigger)").argument("<slug>").option("--json", "Print JSON", false).allowExcessArguments().action(async (slug, options) => {
     const { draftArtistBioCommand: draftArtistBioCommand2 } = await Promise.resolve().then(() => (init_admin_artists(), exports_admin_artists));
     await runEntityBioDraft("artist", slug, options, draftArtistBioCommand2);
@@ -10607,6 +10756,31 @@ JSON field reference:
     const { draftLabelBioCommand: draftLabelBioCommand2 } = await Promise.resolve().then(() => (init_admin_labels(), exports_admin_labels));
     await runEntityBioDraft("label", slug, options, draftLabelBioCommand2);
   });
+  labels.command("artists").description("List or replace one label's artist crawl rules").argument("<slug>", "The label's slug (an exact lbl_\u2026 id also works)").option("--replace", "Replace the complete rule set from --rules-file", false).option("--rules-file <file>", "JSON array of { artistMbid, artistName, verdict } rules").option("--json", "Print JSON", false).action(async (slug, options) => {
+    const {
+      listLabelArtistRulesCommand: listLabelArtistRulesCommand2,
+      parseLabelArtistRulesJson: parseLabelArtistRulesJson2,
+      replaceLabelArtistRulesCommand: replaceLabelArtistRulesCommand2
+    } = await Promise.resolve().then(() => (init_admin_labels(), exports_admin_labels));
+    if (!options.replace && options.rulesFile !== undefined) {
+      throw new Error("Pass --replace with --rules-file");
+    }
+    if (options.replace && options.rulesFile === undefined) {
+      throw new Error("Pass --rules-file <json> with --replace");
+    }
+    const result = options.replace ? await replaceLabelArtistRulesCommand2(slug, parseLabelArtistRulesJson2(readFileSync7(options.rulesFile ?? "", "utf8"))) : await listLabelArtistRulesCommand2(slug);
+    if (options.json) {
+      printJson({ ok: true, rules: result.rules });
+      return;
+    }
+    if (options.replace) {
+      const noun = result.rules.length === 1 ? "rule" : "rules";
+      console.log(artistRuleWriteLine(`${result.rules.length} ${noun} set`));
+      return;
+    }
+    console.log(artistRuleLines(result.rules).join(`
+`));
+  });
   labels.command("update").description("Rule on a label's crawl scope or arm a scoped re-walk (operator)").argument("<slug>", "The label's slug (an exact lbl_\u2026 id also works)").option("--seed-state <state>", "The ruling: enabled, disabled, or undecided").option("--rewalk", "Arm a scoped re-walk without changing the ruling", false).option("--json", "Print JSON", false).action(async (slug, options) => {
     const seedState = options.seedState;
     if (seedState !== undefined && seedState !== "enabled" && seedState !== "disabled" && seedState !== "undecided") {
@@ -10635,12 +10809,14 @@ JSON field reference:
     const {
       aliasWritten,
       canonicalSlug: canon,
+      droppedRules,
       losingSlug: loser,
       reconciled,
       repointed
     } = result;
     console.log(`Merged ${loser} \u2192 ${canon}.`);
     console.log(`  Re-pointed: ${repointed.tracks} track(s), ${repointed.childLabels} sublabel(s), ${repointed.aliases} alias(es).`);
+    console.log(`  Dropped: ${droppedRules} loser-scoped artist rule(s).`);
     console.log(reconciled.length > 0 ? `  Filled onto ${canon} (was empty): ${reconciled.join(", ")}.` : `  Nothing to fill \u2014 ${canon} already carried every fact.`);
     console.log(`  Seed state resolved to: ${result.seedState}.`);
     console.log(`  Alias written: "${aliasWritten.alias}" (${aliasWritten.aliasSlug}) \u2192 confirmed, so it can never re-mint.`);
@@ -11732,21 +11908,26 @@ async function runBackfillLabelImages(options, backfillLabelImagesCommand2) {
 }
 async function runBackfillRecordingMbids(options, backfillRecordingMbidsCommand2) {
   const limit = parseListLimit(options.limit);
+  const isrcRefreshLimit = parseListLimit(options.isrcRefreshLimit);
   const resolved = [];
   const missed = [];
   const failed = [];
+  const isrcRefreshed = [];
+  const isrcRefreshMissed = [];
   let cursor;
   let dryRun = options.dryRun;
   let prefixStripped = 0;
   let throttled = false;
   while (resolved.length + missed.length + failed.length < limit) {
     const remaining = limit - (resolved.length + missed.length + failed.length);
-    const result = await backfillRecordingMbidsCommand2(remaining, options.dryRun, cursor);
+    const result = await backfillRecordingMbidsCommand2(remaining, options.dryRun, cursor, isrcRefreshLimit);
     dryRun = result.dryRun;
     prefixStripped += result.prefixStripped;
     resolved.push(...result.resolved);
     missed.push(...result.missed);
     failed.push(...result.failed);
+    isrcRefreshed.push(...result.isrcRefreshed ?? []);
+    isrcRefreshMissed.push(...result.isrcRefreshMissed ?? []);
     if (!options.json) {
       const verb2 = result.dryRun ? "would resolve" : "resolved";
       console.log(`  \u2026stripped ${result.prefixStripped} from PK; ${verb2} ${result.resolvedCount} by ISRC; ${result.missedCount} not in MusicBrainz; ${result.failedCount} failed`);
@@ -11765,6 +11946,10 @@ async function runBackfillRecordingMbids(options, backfillRecordingMbidsCommand2
       dryRun,
       failed,
       failedCount: failed.length,
+      isrcRefreshMissed,
+      isrcRefreshMissedCount: isrcRefreshMissed.length,
+      isrcRefreshed,
+      isrcRefreshedCount: isrcRefreshed.length,
       missed,
       missedCount: missed.length,
       ok: true,
@@ -11780,6 +11965,7 @@ async function runBackfillRecordingMbids(options, backfillRecordingMbidsCommand2
   }
   const verb = dryRun ? "Would fill" : "Filled";
   console.log(`${verb} ${prefixStripped} recording MBID(s) from crawler PKs; ${resolved.length} by ISRC; ${missed.length} not in MusicBrainz; ${failed.length} failed.`);
+  console.log(`${dryRun ? "Would re-read" : "Re-read"} ${isrcRefreshed.length + isrcRefreshMissed.length} recording(s) for ISRCs \u2014 ${isrcRefreshed.length} filled, ${isrcRefreshMissed.length} still none.`);
   for (const item of failed) {
     console.log(`  ${item.trackId}: ${item.error}`);
   }
@@ -13504,6 +13690,7 @@ function normalizeCommanderError(error) {
   return new Error(message);
 }
 var stringOptions = new Set([
+  "--isrc-refresh-limit",
   "--against",
   "--analyzed-at",
   "--analyzed-from",
@@ -13553,6 +13740,7 @@ var stringOptions = new Set([
   "--mime",
   "--min-phrase-words",
   "--model",
+  "--name",
   "--note",
   "--ok",
   "--order",
@@ -13568,6 +13756,7 @@ var stringOptions = new Set([
   "--reasoning",
   "--recorded-at",
   "--recording",
+  "--rules-file",
   "--render",
   "--scene",
   "--scheduled-for",
@@ -13635,5 +13824,7 @@ if (__require.main == __require.module) {
 export {
   parseTelemetryTimestamp,
   labelUpdateLines,
-  createProgram
+  createProgram,
+  artistRuleLines,
+  ARTIST_RULE_BOUNDARY
 };

package/package.json

@@ -31,5 +31,5 @@
     "url": "git+https://github.com/mauricekleine/fluncle.git"
   },
   "type": "module",
-  "version": "0.219.0"
+  "version": "0.221.0"
 }