fluncle 0.173.0 → 0.175.0

package/bin/fluncle.mjs

@@ -561,7 +561,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.173.0".trim() ? "0.173.0".trim() : "0.1.0";
+  currentVersion = "0.175.0".trim() ? "0.175.0".trim() : "0.1.0";
 });
 
 // src/update-notifier.ts
@@ -2259,7 +2259,7 @@ function parseVersion2(version) {
 var currentVersion2, latestReleaseUrl = "https://api.github.com/repos/mauricekleine/fluncle/releases/latest";
 var init_version2 = __esm(() => {
   init_output();
-  currentVersion2 = "0.173.0".trim() ? "0.173.0".trim() : "0.1.0";
+  currentVersion2 = "0.175.0".trim() ? "0.175.0".trim() : "0.1.0";
 });
 
 // ../../packages/registry/src/index.ts
@@ -2476,7 +2476,7 @@ var init_src = __esm(() => {
       ],
       kind: "web_route",
       name: "web.tracks",
-      operatorNotes: "The top-level track index — the whole archive as one browse list, findings in full voice and the catalogue rows in the unlit register (DESIGN.md). Ordered by tracks.release_date (what came out), never findings.added_at (the Found Rule), keyset-paginated over the tracks_release_date_idx btree so it stays a bounded reverse scan as the catalogue grows (lib/server/tracks-hub.ts). The filter params MIRROR the search vocabulary verbatim (yearMin/yearMax, bpmMin/bpmMax, key, label; galaxy is the one extension). The bare HUB is always indexable + in the sitemap; ANY filter param present flips it to noindex, and the canonical is always the bare /tracks. The INDEX is always-200, so it is HTTP-probeable.",
+      operatorNotes: "The top-level track index — the whole archive as one browse list, findings in full voice and the catalogue rows in the unlit register (DESIGN.md). Ordered by tracks.release_date (what came out), never findings.added_at (the Found Rule), numbered-paginated (?page=N) over the tracks_release_date_idx btree with a quiet YEAR fast lane, so a crawler with no JS walks the whole list (lib/server/tracks-hub.ts). The filter params MIRROR the search vocabulary verbatim (yearMin/yearMax, bpmMin/bpmMax, key, label; galaxy is the one extension). The bare HUB is always indexable + in the sitemap, each page self-canonical; ANY filter param present flips it to noindex, and paged bare URLs stay out of the sitemap. The INDEX is always-200, so it is HTTP-probeable.",
       probeConfig: { cadenceMs: PROBE_CADENCE_MS, kind: "http", timeoutMs: PROBE_TIMEOUT_MS },
       route: "/tracks",
       url: `${SITE}/tracks`,
@@ -3118,6 +3118,23 @@ var init_src = __esm(() => {
       title: "Track crawler",
       weights: { status: "hidden" }
     },
+    {
+      command: "fluncle admin backfills label-releases",
+      exposedContent: [
+        "tap Spotify's fresh releases for the operator's enabled seed labels → day-one uncertified catalogue rows"
+      ],
+      kind: "cron",
+      name: "cron.label-releases",
+      operatorNotes: "every 24h, run by a rave-02 HOST systemd timer (docs/agents/hermes/label-releases-timer/). The FRESHNESS TAP (D8): MusicBrainz WALKS the graph (cron.crawl) but lags a release ~2 weeks; Spotify has it day one, so this searches each ENABLED seed label's fresh releases (`label:\"<name>\" tag:new`, copyright-filtered — the fuzzy `label:` search is post-filtered on the album's ℗/© strings) and mints METADATA-ONLY catalogue rows (a `tracks` row with no `findings` row) with their real release dates — closing the /fresh lag cliff. It certifies nothing, publishes nothing, and never widens the graph (no new labels, no artist hops). Deduped against the MB crawl from both directions (Spotify id/uri/ISRC + same-album title fold). Worker-paced, reusing the publish path's Spotify OAuth (no new secret; Apple was a measured 2/99 seed-label dead end). Zero LLM tokens. Source: docs/agents/hermes/scripts/label-releases-sweep.*. See docs/catalogue-crawler.md.",
+      probeConfig: {
+        cadenceMs: 24 * 60 * MINUTE_MS,
+        cronName: "fluncle-label-releases",
+        kind: "cron"
+      },
+      statusDescription: "taps day-one releases from the enabled labels",
+      title: "Freshness tap",
+      weights: { status: "hidden" }
+    },
     {
       command: "fluncle admin catalogue rank",
       exposedContent: [
@@ -4092,6 +4109,7 @@ __export(exports_admin_tracks, {
   captureQueueCommand: () => captureQueueCommand,
   backfillRecordingMbidsCommand: () => backfillRecordingMbidsCommand,
   backfillLastfmCommand: () => backfillLastfmCommand,
+  backfillLabelReleasesCommand: () => backfillLabelReleasesCommand,
   backfillDiscogsCommand: () => backfillDiscogsCommand,
   backfillAppleMusicCommand: () => backfillAppleMusicCommand,
   backfillAppleCatalogueCommand: () => backfillAppleCatalogueCommand
@@ -4278,6 +4296,10 @@ async function backfillAppleCatalogueCommand(limit, dryRun) {
   const params = new URLSearchParams({ dryRun: String(dryRun), limit: String(limit) });
   return adminApiPost(`/api/admin/backfill/apple-catalogue?${params.toString()}`);
 }
+async function backfillLabelReleasesCommand(limit, dryRun) {
+  const params = new URLSearchParams({ dryRun: String(dryRun), limit: String(limit) });
+  return adminApiPost(`/api/admin/backfill/label-releases?${params.toString()}`);
+}
 async function backfillRecordingMbidsCommand(limit, dryRun, cursor) {
   const params = new URLSearchParams({ dryRun: String(dryRun), limit: String(limit) });
   if (cursor) {
@@ -9657,6 +9679,10 @@ function addAdminCommands(program2) {
     const { backfillAppleCatalogueCommand: backfillAppleCatalogueCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
     await runBackfillAppleCatalogue(options, backfillAppleCatalogueCommand2);
   });
+  backfill.command("label-releases").description("Tap Spotify's fresh releases for enabled seed labels into catalogue rows").option("--dry-run", "Report the labels that would be probed without any Spotify call", false).option("--limit <limit>", "Max enabled seed labels to probe per pass", "5").option("--json", "Print JSON", false).action(async (options) => {
+    const { backfillLabelReleasesCommand: backfillLabelReleasesCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
+    await runBackfillLabelReleases(options, backfillLabelReleasesCommand2);
+  });
   backfill.command("artists").description("Back-fill the artist entity (artists + track_artists) for existing findings").option("--dry-run", "Report which findings would be upserted without touching the DB", false).option("--limit <limit>", "Max findings to process", "50").option("--json", "Print JSON", false).action(async (options) => {
     const { backfillArtistsCommand: backfillArtistsCommand2 } = await Promise.resolve().then(() => (init_admin_artists(), exports_admin_artists));
     await runBackfillArtists(options, backfillArtistsCommand2);
@@ -10350,6 +10376,77 @@ async function runBackfillAppleCatalogue(options, backfillAppleCatalogueCommand2
     process.exitCode = 1;
   }
 }
+async function runBackfillLabelReleases(options, backfillLabelReleasesCommand2) {
+  const perPass = parseListLimit(options.limit);
+  const newTrackIds = [];
+  const labelSlugs = [];
+  const failedLabels = [];
+  let dryRun = options.dryRun;
+  let throttled = false;
+  let configured = true;
+  let labelsProbed = 0;
+  let albumsSeen = 0;
+  let albumsMatched = 0;
+  let newRows = 0;
+  let skippedKnown = 0;
+  const MAX_PASSES = 100;
+  for (let pass = 0;pass < MAX_PASSES; pass += 1) {
+    const result = await backfillLabelReleasesCommand2(perPass, options.dryRun);
+    dryRun = result.dryRun;
+    configured = result.configured;
+    labelsProbed += result.labelsProbed;
+    albumsSeen += result.albumsSeen;
+    albumsMatched += result.albumsMatched;
+    newRows += result.newRows;
+    skippedKnown += result.skippedKnown;
+    newTrackIds.push(...result.newTrackIds);
+    labelSlugs.push(...result.labelSlugs);
+    failedLabels.push(...result.failedLabels);
+    if (!options.json) {
+      const verb2 = result.dryRun ? "would probe" : "probed";
+      console.log(`  \u2026${verb2} ${result.labelSlugs.length} label(s); ${result.albumsMatched} matched album(s); ${result.newRows} new; ${result.skippedKnown} known; ${result.failedLabels.length} failed`);
+    }
+    if (!result.configured) {
+      break;
+    }
+    if (result.rateLimited) {
+      throttled = true;
+      break;
+    }
+    if (result.dryRun) {
+      break;
+    }
+    if (result.labelsProbed === 0) {
+      break;
+    }
+  }
+  if (options.json) {
+    printSweepJson({
+      albumsMatched,
+      albumsSeen,
+      configured,
+      dryRun,
+      failedLabels,
+      labelSlugs,
+      labelsProbed,
+      newRows,
+      newTrackIds,
+      rateLimited: throttled,
+      skippedKnown
+    }, 0);
+    return;
+  }
+  if (!configured) {
+    console.log("Label-releases tap is a no-op \u2014 the Worker's Spotify grant is gone; reconnect Spotify.");
+    return;
+  }
+  const verb = dryRun ? "Would probe" : "Probed";
+  const probedCount = dryRun ? labelSlugs.length : labelsProbed;
+  console.log(`${verb} ${probedCount} enabled seed label(s); ${albumsMatched} matched album(s); ${newRows} new catalogue row(s); ${skippedKnown} already known; ${failedLabels.length} failed.`);
+  for (const slug of failedLabels) {
+    console.log(`  transient Spotify error: ${slug}`);
+  }
+}
 async function runBackfillArtists(options, backfillArtistsCommand2) {
   const limit = parseListLimit(options.limit);
   const upserted = [];

package/package.json

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