perf(sync): tune Spotify search concurrency

Start the opencode resolver while the Spotify playlist snapshot loads so matching can begin sooner.

Raise the default search concurrency from 8 to 10 for better throughput while avoiding the rate limits seen at 20.

Author: mirsella

README.md

@@ -121,7 +121,7 @@ Options:
       --opencode-variant <VARIANT>          opencode variant
       --opencode-base-url <URL>             Existing opencode server URL
       --dry-run                             Print planned Spotify mutations without applying them
-      --concurrency <CONCURRENCY>           Maximum concurrent Spotify search requests [default: 8]
+      --concurrency <CONCURRENCY>           Maximum tracks to search on Spotify at once [default: 10]
       --limit <LIMIT>                       Development/debug cap for tracks to process
   -h, --help                                Print help
   -V, --version                             Print version

src/cli.rs

@@ -4,6 +4,8 @@ use clap::Parser;
 
 use crate::error::{AppError, Result};
 
+const DEFAULT_CONCURRENCY: usize = 10;
+
 #[derive(Debug, Parser)]
 #[command(version, about = "Mirror a YouTube playlist to Spotify")]
 pub struct Cli {
@@ -62,8 +64,8 @@ pub struct Cli {
     #[arg(long)]
     pub dry_run: bool,
 
-    /// Maximum number of concurrent Spotify search requests.
-    #[arg(long, default_value_t = 8)]
+    /// Maximum number of tracks to search on Spotify at once.
+    #[arg(long, default_value_t = DEFAULT_CONCURRENCY)]
     pub concurrency: usize,
 
     /// Development/debug cap for the number of YouTube tracks to process.

src/main.rs

@@ -45,14 +45,21 @@ async fn run(cli: Cli) -> Result<()> {
     )?;
 
     let playlist_name = explicit_name.as_deref().unwrap_or(&youtube_playlist.title);
-    let mut spotify_state = load_spotify_playlist(
-        &progress,
-        spotify,
-        playlist_name,
-        cli.dry_run,
-        explicit_name.is_none(),
-    )
-    .await?;
+    progress.set_phase(if cli.use_opencode() {
+        "loading Spotify playlist and opencode resolver"
+    } else {
+        "loading Spotify playlist"
+    });
+    let (mut spotify_state, opencode) = tokio::try_join!(
+        load_spotify_playlist(
+            &progress,
+            spotify,
+            playlist_name,
+            cli.dry_run,
+            explicit_name.is_none(),
+        ),
+        connect_opencode(&cli, &progress)
+    )?;
 
     if !cli.dry_run && spotify_state.playlist_would_be_created {
         let (playlist, current, playlist_would_be_created) =
@@ -70,18 +77,6 @@ async fn run(cli: Cli) -> Result<()> {
     } = spotify_state;
 
     progress.set_phase("searching and matching Spotify tracks");
-    let opencode = if cli.use_opencode() {
-        Some(
-            opencode::OpencodeResolver::connect(opencode::OpencodeConfig::new(
-                cli.opencode_base_url.clone(),
-                cli.opencode_model.clone(),
-                cli.opencode_variant.clone(),
-            ))
-            .await?,
-        )
-    } else {
-        None
-    };
     let matches = matching::resolve_playlist(
         &spotify,
         &youtube_playlist.tracks,
@@ -200,6 +195,25 @@ async fn connect_spotify(cli: &Cli, progress: &Progress) -> Result<SpotifyClient
     spotify
 }
 
+async fn connect_opencode(
+    cli: &Cli,
+    progress: &Progress,
+) -> Result<Option<opencode::OpencodeResolver>> {
+    if !cli.use_opencode() {
+        return Ok(None);
+    }
+
+    let spinner = progress.spinner("connecting opencode resolver");
+    let resolver = opencode::OpencodeResolver::connect(opencode::OpencodeConfig::new(
+        cli.opencode_base_url.clone(),
+        cli.opencode_model.clone(),
+        cli.opencode_variant.clone(),
+    ))
+    .await;
+    spinner.finish_and_clear();
+    resolver.map(Some)
+}
+
 async fn load_spotify_playlist(
     progress: &Progress,
     spotify: SpotifyClient,