revert: remove unused lastfm agent types and methods from main

Revert lastfm additions from d9a37c9 that are unused on main.
These types and methods belong on the genius-playlist feature branch
where they will be wired up. Fixes clippy dead_code errors in CI.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: pythoninthegrass

crates/mt-tauri/src/lastfm/client.rs

@@ -24,19 +24,6 @@ impl LastFmClient {
         }
     }
 
-    #[cfg(test)]
-    pub(crate) fn new_unconfigured() -> Self {
-        Self {
-            config: ApiKeyConfig {
-                api_key: None,
-                api_secret: None,
-            },
-            rate_limiter: Arc::new(RateLimiter::new()),
-            http_client: reqwest::Client::new(),
-            base_url: "https://ws.audioscrobbler.com/2.0/".to_string(),
-        }
-    }
-
     /// Check if API is properly configured
     pub(crate) fn is_configured(&self) -> bool {
         self.config.is_configured()
@@ -333,106 +320,6 @@ impl LastFmClient {
 
         Ok(scrobble_response.scrobbles.attr.accepted)
     }
-
-    pub(crate) async fn get_similar_tracks(
-        &self,
-        artist: &str,
-        track: &str,
-        limit: u32,
-    ) -> Result<Vec<SimilarTrack>, LastFmError> {
-        let mut params = BTreeMap::new();
-        params.insert("artist".to_string(), artist.to_string());
-        params.insert("track".to_string(), track.to_string());
-        params.insert("limit".to_string(), limit.to_string());
-        params.insert("autocorrect".to_string(), "1".to_string());
-
-        let response = self
-            .api_call("track.getSimilar", params, None, false)
-            .await?;
-
-        let parsed: SimilarTracksResponse =
-            serde_json::from_value(response).map_err(|e| LastFmError::ParseError(e.to_string()))?;
-
-        Ok(parsed.similartracks.track)
-    }
-
-    pub(crate) async fn get_similar_artists(
-        &self,
-        artist: &str,
-        limit: u32,
-    ) -> Result<Vec<SimilarArtist>, LastFmError> {
-        let mut params = BTreeMap::new();
-        params.insert("artist".to_string(), artist.to_string());
-        params.insert("limit".to_string(), limit.to_string());
-        params.insert("autocorrect".to_string(), "1".to_string());
-
-        let response = self
-            .api_call("artist.getSimilar", params, None, false)
-            .await?;
-
-        let parsed: SimilarArtistsResponse =
-            serde_json::from_value(response).map_err(|e| LastFmError::ParseError(e.to_string()))?;
-
-        Ok(parsed.similarartists.artist)
-    }
-
-    pub(crate) async fn get_track_top_tags(
-        &self,
-        artist: &str,
-        track: &str,
-    ) -> Result<Vec<TagInfo>, LastFmError> {
-        let mut params = BTreeMap::new();
-        params.insert("artist".to_string(), artist.to_string());
-        params.insert("track".to_string(), track.to_string());
-        params.insert("autocorrect".to_string(), "1".to_string());
-
-        let response = self
-            .api_call("track.getTopTags", params, None, false)
-            .await?;
-
-        let parsed: TopTagsResponse =
-            serde_json::from_value(response).map_err(|e| LastFmError::ParseError(e.to_string()))?;
-
-        Ok(parsed.toptags.tag)
-    }
-
-    pub(crate) async fn get_top_artists_by_tag(
-        &self,
-        tag: &str,
-        limit: u32,
-    ) -> Result<Vec<TagArtist>, LastFmError> {
-        let mut params = BTreeMap::new();
-        params.insert("tag".to_string(), tag.to_string());
-        params.insert("limit".to_string(), limit.to_string());
-
-        let response = self
-            .api_call("tag.getTopArtists", params, None, false)
-            .await?;
-
-        let parsed: TagTopArtistsResponse =
-            serde_json::from_value(response).map_err(|e| LastFmError::ParseError(e.to_string()))?;
-
-        Ok(parsed.topartists.artist)
-    }
-
-    pub(crate) async fn get_top_tracks_by_country(
-        &self,
-        country: &str,
-        limit: u32,
-    ) -> Result<Vec<GeoTrack>, LastFmError> {
-        let mut params = BTreeMap::new();
-        params.insert("country".to_string(), country.to_string());
-        params.insert("limit".to_string(), limit.to_string());
-
-        let response = self
-            .api_call("geo.getTopTracks", params, None, false)
-            .await?;
-
-        let parsed: GeoTopTracksResponse =
-            serde_json::from_value(response).map_err(|e| LastFmError::ParseError(e.to_string()))?;
-
-        Ok(parsed.tracks.track)
-    }
 }
 
 impl Default for LastFmClient {
@@ -567,115 +454,4 @@ mod tests {
             assert!(matches!(result, Err(LastFmError::NotConfigured)));
         }
     }
-
-    #[test]
-    fn test_parse_similar_tracks_response() {
-        let json: serde_json::Value = serde_json::from_str(
-            r#"{
-                "similartracks": {
-                    "track": [
-                        {"name": "Track A", "artist": {"name": "Artist A"}, "match": "0.95"},
-                        {"name": "Track B", "artist": {"name": "Artist B"}, "match": "0.80"}
-                    ]
-                }
-            }"#,
-        )
-        .unwrap();
-
-        let parsed: SimilarTracksResponse = serde_json::from_value(json).unwrap();
-        assert_eq!(parsed.similartracks.track.len(), 2);
-        assert_eq!(parsed.similartracks.track[0].name, "Track A");
-        assert_eq!(parsed.similartracks.track[0].artist.name(), "Artist A");
-        assert_eq!(
-            parsed.similartracks.track[0].match_score.as_deref(),
-            Some("0.95")
-        );
-    }
-
-    #[test]
-    fn test_parse_similar_artists_response() {
-        let json: serde_json::Value = serde_json::from_str(
-            r#"{
-                "similarartists": {
-                    "artist": [
-                        {"name": "Artist X", "match": "0.90"},
-                        {"name": "Artist Y", "match": "0.75"}
-                    ]
-                }
-            }"#,
-        )
-        .unwrap();
-
-        let parsed: SimilarArtistsResponse = serde_json::from_value(json).unwrap();
-        assert_eq!(parsed.similarartists.artist.len(), 2);
-        assert_eq!(parsed.similarartists.artist[0].name, "Artist X");
-    }
-
-    #[test]
-    fn test_parse_top_tags_response() {
-        let json: serde_json::Value = serde_json::from_str(
-            r#"{
-                "toptags": {
-                    "tag": [
-                        {"name": "rock", "count": 100},
-                        {"name": "alternative", "count": 80}
-                    ]
-                }
-            }"#,
-        )
-        .unwrap();
-
-        let parsed: TopTagsResponse = serde_json::from_value(json).unwrap();
-        assert_eq!(parsed.toptags.tag.len(), 2);
-        assert_eq!(parsed.toptags.tag[0].name, "rock");
-        assert_eq!(parsed.toptags.tag[0].count, Some(100));
-    }
-
-    #[test]
-    fn test_parse_tag_top_artists_response() {
-        let json: serde_json::Value = serde_json::from_str(
-            r#"{
-                "topartists": {
-                    "artist": [
-                        {"name": "Radiohead"},
-                        {"name": "Muse"}
-                    ]
-                }
-            }"#,
-        )
-        .unwrap();
-
-        let parsed: TagTopArtistsResponse = serde_json::from_value(json).unwrap();
-        assert_eq!(parsed.topartists.artist.len(), 2);
-        assert_eq!(parsed.topartists.artist[0].name, "Radiohead");
-    }
-
-    #[test]
-    fn test_parse_geo_top_tracks_response() {
-        let json: serde_json::Value = serde_json::from_str(
-            r#"{
-                "tracks": {
-                    "track": [
-                        {"name": "Bohemian Rhapsody", "artist": {"name": "Queen"}},
-                        {"name": "Imagine", "artist": {"name": "John Lennon"}}
-                    ]
-                }
-            }"#,
-        )
-        .unwrap();
-
-        let parsed: GeoTopTracksResponse = serde_json::from_value(json).unwrap();
-        assert_eq!(parsed.tracks.track.len(), 2);
-        assert_eq!(parsed.tracks.track[0].name, "Bohemian Rhapsody");
-        assert_eq!(parsed.tracks.track[0].artist.name(), "Queen");
-    }
-
-    #[test]
-    fn test_parse_similar_tracks_empty() {
-        let json: serde_json::Value =
-            serde_json::from_str(r#"{"similartracks": {"track": []}}"#).unwrap();
-
-        let parsed: SimilarTracksResponse = serde_json::from_value(json).unwrap();
-        assert!(parsed.similartracks.track.is_empty());
-    }
 }

crates/mt-tauri/src/lastfm/types.rs

@@ -252,88 +252,6 @@ pub struct NowPlayingApiResponse {
     pub nowplaying: HashMap<String, serde_json::Value>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SimilarTracksResponse {
-    pub similartracks: SimilarTracksContainer,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SimilarTracksContainer {
-    pub track: Vec<SimilarTrack>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SimilarTrack {
-    pub name: String,
-    pub artist: ArtistInfo,
-    #[serde(rename = "match")]
-    pub match_score: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SimilarArtistsResponse {
-    pub similarartists: SimilarArtistsContainer,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SimilarArtistsContainer {
-    pub artist: Vec<SimilarArtist>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SimilarArtist {
-    pub name: String,
-    #[serde(rename = "match")]
-    pub match_score: Option<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TopTagsResponse {
-    pub toptags: TopTagsContainer,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TopTagsContainer {
-    pub tag: Vec<TagInfo>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TagInfo {
-    pub name: String,
-    pub count: Option<u32>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TagTopArtistsResponse {
-    pub topartists: TagTopArtistsContainer,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TagTopArtistsContainer {
-    pub artist: Vec<TagArtist>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TagArtist {
-    pub name: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct GeoTopTracksResponse {
-    pub tracks: GeoTopTracksContainer,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct GeoTopTracksContainer {
-    pub track: Vec<GeoTrack>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct GeoTrack {
-    pub name: String,
-    pub artist: ArtistInfo,
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;