fluncle 0.99.0 → 0.101.0

package/bin/fluncle.mjs

@@ -557,7 +557,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.99.0".trim() ? "0.99.0".trim() : "0.1.0";
+  currentVersion = "0.101.0".trim() ? "0.101.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.99.0".trim() ? "0.99.0".trim() : "0.1.0";
+  currentVersion2 = "0.101.0".trim() ? "0.101.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"],
@@ -2790,6 +2841,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: [
@@ -5097,6 +5169,39 @@ var init_auth_lastfm = __esm(() => {
   init_api();
 });
 
+// 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) {
+    params.set("cursor", 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();
+});
+
 // src/interactive.ts
 var exports_interactive = {};
 __export(exports_interactive, {
@@ -7560,6 +7665,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);
@@ -7898,6 +8007,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();
@@ -7914,6 +8031,19 @@ function addAdminCommands(program2) {
     const { backfillDiscogsCommand: backfillDiscogsCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
     await runBackfillDiscogs(options, backfillDiscogsCommand2);
   });
+  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);
+  });
+  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) {
@@ -8126,6 +8256,133 @@ async function runBackfillDiscogs(options, backfillDiscogsCommand2) {
     console.log(`  ${item.logId}: release ${item.releaseId}${master}`);
   }
 }
+async function runBackfillArtists(options, backfillArtistsCommand2) {
+  const limit = parseListLimit(options.limit);
+  const upserted = [];
+  const failed = [];
+  const skipped = [];
+  let cursor;
+  let dryRun = options.dryRun;
+  while (upserted.length + failed.length < limit) {
+    const remaining = limit - (upserted.length + failed.length);
+    const result = await backfillArtistsCommand2(remaining, options.dryRun, cursor);
+    dryRun = result.dryRun;
+    upserted.push(...result.upserted);
+    failed.push(...result.failed);
+    skipped.push(...result.skipped);
+    if (!options.json) {
+      const verb2 = result.dryRun ? "would upsert" : "upserted";
+      console.log(`  \u2026${verb2} ${result.upsertedCount}; ${result.failedCount} failed; ${result.skippedCount} skipped`);
+    }
+    if (result.nextCursor === null) {
+      break;
+    }
+    cursor = result.nextCursor;
+  }
+  if (options.json) {
+    printJson({
+      dryRun,
+      failed,
+      failedCount: failed.length,
+      ok: true,
+      skipped,
+      skippedCount: skipped.length,
+      upserted,
+      upsertedCount: upserted.length
+    });
+    return;
+  }
+  const verb = dryRun ? "Would upsert" : "Upserted";
+  console.log(`${verb} ${upserted.length} artist entity row(s); ${failed.length} failed; ${skipped.length} skipped.`);
+  for (const logId of upserted) {
+    console.log(`  ${logId}`);
+  }
+  for (const item of failed) {
+    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]");
@@ -8629,6 +8886,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) {

package/package.json

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