fluncle 0.100.0 → 0.102.0

package/bin/fluncle.mjs

@@ -557,7 +557,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.100.0".trim() ? "0.100.0".trim() : "0.1.0";
+  currentVersion = "0.102.0".trim() ? "0.102.0".trim() : "0.1.0";
 });
 
 // src/update-notifier.ts
@@ -1022,6 +1022,24 @@ var init_recent = __esm(() => {
   init_api();
 });
 
+// src/commands/artists.ts
+var exports_artists = {};
+__export(exports_artists, {
+  artistsListCommand: () => artistsListCommand,
+  artistsGetCommand: () => artistsGetCommand
+});
+async function artistsListCommand() {
+  const response = await publicApiGet("/api/v1/artists");
+  return response.artists;
+}
+async function artistsGetCommand(slug) {
+  const response = await publicApiGet(`/api/v1/artists/${encodeURIComponent(slug)}`);
+  return response.artist;
+}
+var init_artists = __esm(() => {
+  init_api();
+});
+
 // src/commands/mixtape-api.ts
 async function mixtapeListCommand() {
   const response = await adminApiGet("/api/admin/mixtapes");
@@ -2187,7 +2205,7 @@ function parseVersion2(version) {
 var currentVersion2, latestReleaseUrl = "https://api.github.com/repos/mauricekleine/fluncle/releases/latest";
 var init_version2 = __esm(() => {
   init_output();
-  currentVersion2 = "0.100.0".trim() ? "0.100.0".trim() : "0.1.0";
+  currentVersion2 = "0.102.0".trim() ? "0.102.0".trim() : "0.1.0";
 });
 
 // ../../packages/registry/src/index.ts
@@ -2308,6 +2326,18 @@ var init_src = __esm(() => {
       url: `${SITE}/radio`,
       weights: { web: "secondary" }
     },
+    {
+      discoveryUrl: `${SITE}/llms.txt`,
+      exposedContent: [
+        "/artist/:slug — one artist's page: every published finding from that artist, plus their identity links"
+      ],
+      kind: "web_route",
+      name: "web.artist",
+      operatorNotes: "Slug is real-name kebab-case (e.g. /artist/dbridge). Read-only; only artists with at least one published finding resolve (others 404). No probeConfig — the route is slug-parameterized, so there is no fixed URL to GET-probe.",
+      route: "/artist",
+      url: `${SITE}/artist`,
+      weights: { ssh: "secondary", web: "secondary" }
+    },
     {
       exposedContent: ["the privacy policy"],
       kind: "web_route",
@@ -2420,6 +2450,20 @@ var init_src = __esm(() => {
       url: `${SITE}/api/v1/mixtapes`,
       weights: { web: "secondary" }
     },
+    {
+      apiFormat: "application/json",
+      discoveryUrl: `${SITE}/api/v1/openapi.json`,
+      exposedContent: [
+        "every artist with at least one published finding, finding-count ordered, as JSON",
+        "/api/v1/artists/{slug} — one artist's identity and finding count, as JSON"
+      ],
+      kind: "api",
+      name: "api.artists",
+      probeConfig: { cadenceMs: PROBE_CADENCE_MS, kind: "http", timeoutMs: PROBE_TIMEOUT_MS },
+      route: "/api/v1/artists",
+      url: `${SITE}/api/v1/artists`,
+      weights: { web: "secondary" }
+    },
     {
       apiFormat: "application/json",
       discoveryUrl: `${SITE}/api/v1/openapi.json`,
@@ -2657,6 +2701,13 @@ var init_src = __esm(() => {
       name: "cli.mixtapes",
       weights: { cli: "secondary" }
     },
+    {
+      command: "fluncle artists",
+      exposedContent: ["every artist with at least one published finding (bare `slug` looks one up)"],
+      kind: "cli",
+      name: "cli.artists",
+      weights: { cli: "secondary" }
+    },
     {
       command: "fluncle open",
       exposedContent: ["pick a track, open it in Spotify"],
@@ -2748,6 +2799,17 @@ var init_src = __esm(() => {
       probeConfig: { cadenceMs: 5 * MINUTE_MS, cronName: "fluncle-embed", kind: "cron" },
       weights: { status: "hidden" }
     },
+    {
+      command: "fluncle admin tracks capture-audio --queue",
+      exposedContent: [
+        "capture each finding's full song once → private R2 (yt-dlp via a residential proxy)"
+      ],
+      kind: "cron",
+      name: "cron.capture",
+      operatorNotes: "every 5m, run by a rave-02 HOST systemd timer (docs/agents/hermes/capture-timer/) — NOT a gateway cron: a proxied yt-dlp fetch has an unbounded tail that would starve the 5-min enrich/context/note sweeps on the shared serial runner. A NON-BLOCKING side-channel (never gates enrich/embed). Runs yt-dlp through a residential proxy on a per-track sticky session, duration-guards the match, stores the full song in the PRIVATE fluncle-source-audio bucket (S3-direct), and writes back via the agent-tier update_track (with per-finding backoff). yt-dlp + ffprobe are a box deploy prereq. Newest-first so a fresh add jumps the backfill. Source: docs/agents/hermes/scripts/capture-sweep.*. See docs/full-audio-rfc.md § Unit 1.",
+      probeConfig: { cadenceMs: 5 * MINUTE_MS, cronName: "fluncle-capture", kind: "cron" },
+      weights: { status: "hidden" }
+    },
     {
       command: "fluncle admin tracks context --queue",
       exposedContent: [
@@ -2790,6 +2852,27 @@ var init_src = __esm(() => {
       probeConfig: { cadenceMs: 30 * MINUTE_MS, cronName: "fluncle-backfill", kind: "cron" },
       weights: { status: "hidden" }
     },
+    {
+      exposedContent: [
+        "resolve each artist's social identity: MB url-rel walk + Firecrawl gap-fill (TikTok + YouTube)"
+      ],
+      kind: "cron",
+      name: "cron.artist-sweep",
+      operatorNotes: "every 60m. --no-agent trigger; the Worker does the MB walk + Firecrawl /v2/extract + YouTube channel resolution. Zero on-box tokens. MB rows land as status=auto (trusted); Firecrawl rows as status=candidate (operator-confirm before public). Source: docs/agents/hermes/scripts/artist-sweep.*",
+      probeConfig: { cadenceMs: 60 * MINUTE_MS, cronName: "fluncle-artist-sweep", kind: "cron" },
+      weights: { status: "hidden" }
+    },
+    {
+      command: "fluncle admin artists follow",
+      exposedContent: [
+        "auto-follow high-confidence artists on Spotify + YouTube — the championing motion (--no-agent, Worker HTTP)"
+      ],
+      kind: "cron",
+      name: "cron.artist-follow",
+      operatorNotes: "every 6h. Pure HTTP trigger, zero LLM tokens. Agent tier (the box holds no Spotify/YouTube tokens; the Worker does the PUT /me/following + subscriptions.insert and stamps followed_at). Idempotent by followed_at IS NULL, acting only on status IN (auto, confirmed); quota-paced. Mixcloud is link-only (cut). Source: docs/agents/hermes/scripts/artist-follow-sweep.*. Probed on /status as cron.artist-follow.",
+      probeConfig: { cadenceMs: 6 * 60 * MINUTE_MS, cronName: "fluncle-artist-follow", kind: "cron" },
+      weights: { status: "hidden" }
+    },
     {
       command: "fluncle admin tracks social --capture",
       exposedContent: [
@@ -3457,11 +3540,13 @@ __export(exports_admin_tracks, {
   enrichQueueCommand: () => enrichQueueCommand,
   embedQueueCommand: () => embedQueueCommand,
   contextQueueCommand: () => contextQueueCommand,
+  captureQueueCommand: () => captureQueueCommand,
   backfillLastfmCommand: () => backfillLastfmCommand,
   backfillDiscogsCommand: () => backfillDiscogsCommand
 });
 async function fetchAdminTracks(options) {
   const {
+    captureQueue,
     hasContext,
     hasEmbedding,
     hasKey,
@@ -3486,6 +3571,9 @@ async function fetchAdminTracks(options) {
     if (hasEmbedding !== undefined) {
       params.set("hasEmbedding", String(hasEmbedding));
     }
+    if (captureQueue) {
+      params.set("captureQueue", "true");
+    }
     if (hasContext !== undefined) {
       params.set("hasContext", String(hasContext));
     }
@@ -3541,6 +3629,9 @@ async function enrichQueueCommand(limit) {
 async function embedQueueCommand(limit) {
   return fetchAdminTracks({ hasEmbedding: false, max: limit, order: "asc" });
 }
+async function captureQueueCommand(limit) {
+  return fetchAdminTracks({ captureQueue: true, max: limit, order: "desc" });
+}
 async function contextQueueCommand(limit, retryEmptyContext = false) {
   return fetchAdminTracks({ hasContext: false, max: limit, order: "asc", retryEmptyContext });
 }
@@ -5100,8 +5191,21 @@ var init_auth_lastfm = __esm(() => {
 // src/commands/admin-artists.ts
 var exports_admin_artists = {};
 __export(exports_admin_artists, {
+  resolveArtistCommand: () => resolveArtistCommand,
+  listArtistsCommand: () => listArtistsCommand,
+  followArtistsCommand: () => followArtistsCommand,
   backfillArtistsCommand: () => backfillArtistsCommand
 });
+async function listArtistsCommand(limit, cursor) {
+  const params = new URLSearchParams({ limit: String(limit) });
+  if (cursor) {
+    params.set("cursor", cursor);
+  }
+  return adminApiGet(`/api/admin/artists?${params.toString()}`);
+}
+async function resolveArtistCommand(artistId) {
+  return adminApiPost(`/api/admin/artists/${encodeURIComponent(artistId)}/resolve`);
+}
 async function backfillArtistsCommand(limit, dryRun, cursor) {
   const params = new URLSearchParams({ dryRun: String(dryRun), limit: String(limit) });
   if (cursor) {
@@ -5109,6 +5213,10 @@ async function backfillArtistsCommand(limit, dryRun, cursor) {
   }
   return adminApiPost(`/api/admin/backfill/artists?${params.toString()}`);
 }
+async function followArtistsCommand(limit, dryRun) {
+  const params = new URLSearchParams({ dryRun: String(dryRun), limit: String(limit) });
+  return adminApiPost(`/api/admin/artists/follow?${params.toString()}`);
+}
 var init_admin_artists = __esm(() => {
   init_api();
 });
@@ -7576,6 +7684,10 @@ function addListenCommands(program2) {
     const { recentCommand: recentCommand3 } = await Promise.resolve().then(() => (init_recent(), exports_recent));
     await runRecent(options, recentCommand3);
   });
+  program2.command("artists").description("Browse artists in Fluncle's archive").argument("[slug]", "Artist slug \u2014 omit for the full list").option("--json", "Print JSON", false).action(async (slug, options) => {
+    const { artistsListCommand: artistsListCommand2, artistsGetCommand: artistsGetCommand2 } = await Promise.resolve().then(() => (init_artists(), exports_artists));
+    await runArtists(slug, options, { artistsGetCommand: artistsGetCommand2, artistsListCommand: artistsListCommand2 });
+  });
   program2.command("mixtapes").description("Fluncle's checkpoint sets").option("--json", "Print JSON", false).action(async (options) => {
     const { mixtapesCommand: mixtapesCommand2 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
     await runMixtapes(options, mixtapesCommand2);
@@ -7694,6 +7806,15 @@ function addAdminCommands(program2) {
     const { embedQueueCommand: embedQueueCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
     await runAdminEmbedQueue(options, embedQueueCommand2);
   });
+  adminTracks.command("capture-audio").description("Full-song capture worklist (findings with no source audio yet) \u2014 use --queue").option("--queue", "Show the capture worklist, newest first", false).option("--limit <limit>", "Number of findings to show with --queue", "10").option("--json", "Print JSON", false).action(async (options) => {
+    if (!options.queue) {
+      console.error("`tracks capture-audio` is a worklist view \u2014 capture runs on the on-box `fluncle-capture` cron.\nUse `tracks capture-audio --queue` to see findings needing a full-song capture.");
+      process.exitCode = 1;
+      return;
+    }
+    const { captureQueueCommand: captureQueueCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
+    await runAdminCaptureQueue(options, captureQueueCommand2);
+  });
   adminTracks.command("vehicles").description("Recent video vehicles, newest first (the style ledger for diversity)").option("--limit <limit>", "Number of vehicles to show", "10").option("--json", "Print JSON", false).action(async (options) => {
     const { vehiclesCommand: vehiclesCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
     await runAdminVehicles(options, vehiclesCommand2);
@@ -7914,6 +8035,14 @@ function addAdminCommands(program2) {
     const { authLastfmCommand: authLastfmCommand2 } = await Promise.resolve().then(() => (init_auth_lastfm(), exports_auth_lastfm));
     await authLastfmCommand2(options);
   });
+  const artists = configureCommand(admin.command("artists").description("Artist entity + championing commands"));
+  artists.action(() => {
+    artists.outputHelp();
+  });
+  artists.command("follow").description("Auto-follow high-confidence artists on Spotify + YouTube (drains the queue)").option("--dry-run", "Report who WOULD be followed without calling the platforms", false).option("--limit <limit>", "Max artists to follow this run", "20").option("--json", "Print JSON", false).action(async (options) => {
+    const { followArtistsCommand: followArtistsCommand2 } = await Promise.resolve().then(() => (init_admin_artists(), exports_admin_artists));
+    await runFollowArtists(options, followArtistsCommand2);
+  });
   const backfill = configureCommand(admin.command("backfills").description("Backfill operator-only archives"));
   backfill.action(() => {
     backfill.outputHelp();
@@ -7934,6 +8063,15 @@ function addAdminCommands(program2) {
     const { backfillArtistsCommand: backfillArtistsCommand2 } = await Promise.resolve().then(() => (init_admin_artists(), exports_admin_artists));
     await runBackfillArtists(options, backfillArtistsCommand2);
   });
+  artists.command("resolve").description("Resolve an artist's social identity (MB url-rels + Firecrawl gap-fill)").argument("[artistId]").option("--queue", "Show the resolve worklist (artists awaiting resolution), oldest first", false).option("--limit <limit>", "Number of artists to show with --queue", "50").option("--json", "Print JSON", false).allowExcessArguments().action(async (artistId, options) => {
+    if (options.queue) {
+      const { listArtistsCommand: listArtistsCommand2 } = await Promise.resolve().then(() => (init_admin_artists(), exports_admin_artists));
+      await runArtistResolveQueue(options, listArtistsCommand2);
+      return;
+    }
+    const { resolveArtistCommand: resolveArtistCommand2 } = await Promise.resolve().then(() => (init_admin_artists(), exports_admin_artists));
+    await runArtistResolve(artistId, options, resolveArtistCommand2);
+  });
 }
 async function runTrackPreviewArchive(idOrLogId, options, previewArchiveUploadCommand2) {
   if (!idOrLogId || !options.file || !options.source || !options.mime) {
@@ -8191,6 +8329,88 @@ async function runBackfillArtists(options, backfillArtistsCommand2) {
     console.log(`  ${item.logId}: ${item.error}`);
   }
 }
+async function runArtistResolveQueue(options, listArtistsCommand2) {
+  const limit = parseListLimit(options.limit);
+  const result = await listArtistsCommand2(limit ?? 50);
+  if (options.json) {
+    printJson({ artists: result.artists, ok: true });
+    return;
+  }
+  if (result.artists.length === 0) {
+    console.log("Every artist has been resolved. Nothing waiting on the sweep.");
+    return;
+  }
+  const noun = result.artists.length === 1 ? "artist" : "artists";
+  console.log(`${result.artists.length} ${noun} awaiting resolution, oldest first:`);
+  for (const artist of result.artists) {
+    console.log(`  ${artist.id}  ${artist.name}`);
+  }
+}
+async function runArtistResolve(artistId, options, resolveArtistCommand2) {
+  if (!artistId) {
+    throw new Error("Usage: fluncle admin artists resolve <artist_id> [--json]");
+  }
+  const result = await resolveArtistCommand2(artistId);
+  if (options.json) {
+    printJson(result);
+    return;
+  }
+  if (result.rateLimited) {
+    console.log(`MusicBrainz throttled the walk for ${artistId}. The sweep will swing back around.`);
+    return;
+  }
+  const mbid = result.mbid ?? "(no MusicBrainz match)";
+  const noun = result.socialsCount === 1 ? "social" : "socials";
+  console.log(`Resolved ${artistId}: mbid=${mbid}, ${result.socialsCount} ${noun}.`);
+  for (const social of result.socials) {
+    console.log(`  ${social.platform} (${social.source}): ${social.url}`);
+  }
+  if (result.wikidataQid) {
+    console.log(`  wikidata: ${result.wikidataQid}`);
+  }
+}
+async function runFollowArtists(options, followArtistsCommand2) {
+  const limit = parseListLimit(options.limit);
+  const followed = [];
+  const failed = [];
+  let dryRun = options.dryRun;
+  let remaining = 0;
+  while (followed.length + failed.length < limit) {
+    const batchLimit = Math.min(50, limit - (followed.length + failed.length));
+    const result = await followArtistsCommand2(batchLimit, options.dryRun);
+    dryRun = result.dryRun;
+    remaining = result.remaining;
+    followed.push(...result.followed);
+    failed.push(...result.failed);
+    if (!options.json) {
+      const verb2 = result.dryRun ? "would follow" : "followed";
+      console.log(`  \u2026${verb2} ${result.followedCount}; ${result.failedCount} failed; ${result.remaining} remaining`);
+    }
+    if (remaining === 0 || result.dryRun || result.followedCount === 0) {
+      break;
+    }
+  }
+  if (options.json) {
+    printJson({
+      dryRun,
+      failed,
+      failedCount: failed.length,
+      followed,
+      followedCount: followed.length,
+      ok: true,
+      remaining
+    });
+    return;
+  }
+  const verb = dryRun ? "Would follow" : "Followed";
+  console.log(`${verb} ${followed.length} artist(s); ${failed.length} failed; ${remaining} remaining.`);
+  for (const item of followed) {
+    console.log(`  ${item.platform}: ${item.artistName}`);
+  }
+  for (const item of failed) {
+    console.log(`  ${item.platform} ${item.socialId}: ${item.error}`);
+  }
+}
 async function runTrackVideo(idOrLogId, options, trackVideoCommand2) {
   if (!idOrLogId) {
     throw new Error("Missing id. Usage: fluncle admin tracks video <track_id|log_id> (--dir <dir> | --footage <file> [--footage-social <file>] [--footage-notext <file>] [--footage-landscape <file>] [--footage-landscape-social <file>] [--poster <file>] [--cover <file>] [--note <file>] [--composition <file>] [--props <file>] [--render <file>] [--intent <file>] [--metrics <file>] [--scene <file>] | --plate <file> [--plate-background <file>]) [--allow-partial]");
@@ -8694,6 +8914,33 @@ async function runRecent(options, recentCommand3) {
   console.log(trackRows2(tracks).join(`
 `));
 }
+async function runArtists(slug, options, commands) {
+  if (slug) {
+    const artist = await commands.artistsGetCommand(slug);
+    if (options.json) {
+      printJson({ artist, ok: true });
+      return;
+    }
+    console.log(`${artist.name}  (${artist.slug})`);
+    console.log(`Findings: ${artist.findingCount}`);
+    if (artist.spotifyUrl) {
+      console.log(`Spotify: ${artist.spotifyUrl}`);
+    }
+    return;
+  }
+  const artists = await commands.artistsListCommand();
+  if (options.json) {
+    printJson({ artists, ok: true });
+    return;
+  }
+  if (artists.length === 0) {
+    console.log("No artists in the archive yet.");
+    return;
+  }
+  for (const a of artists) {
+    console.log(`${a.name.padEnd(40)} ${String(a.findingCount).padStart(3)} finding${a.findingCount === 1 ? "" : "s"}`);
+  }
+}
 async function runMixtapes(options, mixtapesCommand2) {
   const mixtapes = await mixtapesCommand2();
   if (options.json) {
@@ -8872,6 +9119,26 @@ async function runAdminEmbedQueue(options, embedQueueCommand2) {
   console.log(trackRows2(tracks).join(`
 `));
 }
+async function runAdminCaptureQueue(options, captureQueueCommand2) {
+  const limit = parseListLimit(options.limit);
+  const tracks = await captureQueueCommand2(limit);
+  if (options.json) {
+    printJson({
+      ok: true,
+      tracks
+    });
+    return;
+  }
+  if (tracks.length === 0) {
+    console.log("Nothing awaiting a capture. Every finding has its full song.");
+    return;
+  }
+  const { trackRows: trackRows2 } = await Promise.resolve().then(() => (init_format2(), exports_format));
+  const noun = tracks.length === 1 ? "finding" : "findings";
+  console.log(`${tracks.length} ${noun} needing a full-song capture, newest first:`);
+  console.log(trackRows2(tracks).join(`
+`));
+}
 async function runAdminVehicles(options, vehiclesCommand2) {
   const limit = parseListLimit(options.limit);
   const vehicles = await vehiclesCommand2(limit);

package/package.json

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