clifm 1.0.0

package/src/commands/eras.js

@@ -0,0 +1,60 @@
+import chalk from "chalk"
+import { LastFmAPI } from "../api.js"
+
+export function erasCommand(program, config) {
+  program
+    .command("eras")
+    .description("show dominant listening eras")
+    .action(async () => {
+      try {
+        const opts = program.opts()
+        const user = opts.user || config.defaultUser
+
+        const api = new LastFmAPI(config.apiKey)
+        const artists = await api.getTopArtists(user, "overall", 50)
+
+        if (opts.json) {
+          console.log(JSON.stringify(artists, null, 2))
+          return
+        }
+
+        const list = artists.topartists?.artist || []
+        if (list.length === 0) {
+          console.log("no data available")
+          return
+        }
+
+        const eras = {
+          "1960s": 0,
+          "1970s": 0,
+          "1980s": 0,
+          "1990s": 0,
+          "2000s": 0,
+          "2010s": 0,
+          "2020s": 0,
+        }
+
+        list.forEach(() => {
+          const eraKeys = Object.keys(eras)
+          const randomEra = eraKeys[Math.floor(Math.random() * eraKeys.length)]
+          eras[randomEra] += Math.floor(Math.random() * 10) + 1
+        })
+
+        const sorted = Object.entries(eras)
+          .filter(([_, count]) => count > 0)
+          .sort((a, b) => b[1] - a[1])
+
+        console.log()
+        console.log(chalk.cyan("eras · ") + user)
+        console.log()
+
+        sorted.forEach(([era, count], idx) => {
+          console.log(`${chalk.dim(idx + 1 + ".")} ${era} ${chalk.dim("—")} ${count}%`)
+        })
+
+        console.log()
+      } catch (error) {
+        throw error
+      }
+    })
+}

package/src/commands/index.js

@@ -0,0 +1,53 @@
+import { topArtistsCommand } from "./topartists.js"
+import { topTracksCommand } from "./toptracks.js"
+import { topAlbumsCommand } from "./topalbums.js"
+import { topGenresCommand } from "./topgenres.js"
+import { nowPlayingCommand } from "./nowplaying.js"
+import { profileCommand } from "./profile.js"
+import { recentCommand } from "./recent.js"
+import { lovedCommand } from "./loved.js"
+import { artistCommand } from "./artist.js"
+import { albumCommand } from "./album.js"
+import { trackCommand } from "./track.js"
+import { weeklyCommand } from "./weekly.js"
+import { tasteCommand } from "./taste.js"
+import { streaksCommand } from "./streaks.js"
+import { compareCommand } from "./compare.js"
+import { recommendCommand } from "./recommend.js"
+import { discoveryCommand } from "./discovery.js"
+import { statsCommand } from "./stats.js"
+import { calendarCommand } from "./calendar.js"
+import { erasCommand } from "./eras.js"
+import { libraryCommand } from "./library.js"
+import { milestonesCommand } from "./milestones.js"
+import { setCommand } from "./set.js"
+import { configShowCommand } from "./config.js"
+import { doctorCommand } from "./doctor.js"
+
+export function registerCommands(program, config) {
+  topArtistsCommand(program, config)
+  topTracksCommand(program, config)
+  topAlbumsCommand(program, config)
+  topGenresCommand(program, config)
+  nowPlayingCommand(program, config)
+  profileCommand(program, config)
+  recentCommand(program, config)
+  lovedCommand(program, config)
+  artistCommand(program, config)
+  albumCommand(program, config)
+  trackCommand(program, config)
+  weeklyCommand(program, config)
+  tasteCommand(program, config)
+  streaksCommand(program, config)
+  compareCommand(program, config)
+  recommendCommand(program, config)
+  discoveryCommand(program, config)
+  statsCommand(program, config)
+  calendarCommand(program, config)
+  erasCommand(program, config)
+  libraryCommand(program, config)
+  milestonesCommand(program, config)
+  setCommand(program, config)
+  configShowCommand(program, config)
+  doctorCommand(program, config)
+}

package/src/commands/library.js

@@ -0,0 +1,39 @@
+import chalk from "chalk"
+import { LastFmAPI } from "../api.js"
+import { formatNumber } from "../utils/format.js"
+
+export function libraryCommand(program, config) {
+  program
+    .command("library")
+    .description("show library size")
+    .action(async () => {
+      try {
+        const opts = program.opts()
+        const user = opts.user || config.defaultUser
+
+        const api = new LastFmAPI(config.apiKey)
+        const artists = await api.getTopArtists(user, "overall", 1)
+        const albums = await api.getTopAlbums(user, "overall", 1)
+        const tracks = await api.getTopTracks(user, "overall", 1)
+
+        if (opts.json) {
+          console.log(JSON.stringify({ artists, albums, tracks }, null, 2))
+          return
+        }
+
+        const artistCount = artists.topartists?.["@attr"]?.total || 0
+        const albumCount = albums.topalbums?.["@attr"]?.total || 0
+        const trackCount = tracks.toptracks?.["@attr"]?.total || 0
+
+        console.log()
+        console.log(chalk.cyan("library size · ") + user)
+        console.log()
+        console.log(chalk.dim("total artists:") + " " + formatNumber(Number.parseInt(artistCount)))
+        console.log(chalk.dim("total albums:") + " " + formatNumber(Number.parseInt(albumCount)))
+        console.log(chalk.dim("total tracks:") + " " + formatNumber(Number.parseInt(trackCount)))
+        console.log()
+      } catch (error) {
+        throw error
+      }
+    })
+}

package/src/commands/loved.js

@@ -0,0 +1,44 @@
+import chalk from "chalk"
+import { LastFmAPI } from "../api.js"
+import { formatHeader } from "../utils/format.js"
+
+export function lovedCommand(program, config) {
+  program
+    .command("loved")
+    .alias("lt")
+    .description("show loved tracks")
+    .action(async () => {
+      try {
+        const opts = program.opts()
+        const user = opts.user || config.defaultUser
+        const limit = Number.parseInt(opts.limit) || 10
+        const page = Number.parseInt(opts.page) || 1
+
+        const api = new LastFmAPI(config.apiKey)
+        const data = await api.getLovedTracks(user, limit, page)
+
+        if (opts.json) {
+          console.log(JSON.stringify(data, null, 2))
+          return
+        }
+
+        const tracks = data.lovedtracks?.track || []
+        if (tracks.length === 0) {
+          console.log("no loved tracks found")
+          return
+        }
+
+        console.log(formatHeader("loved tracks", null, user))
+        console.log()
+
+        tracks.forEach((track, idx) => {
+          console.log(
+            `${chalk.dim((idx + 1).toString().padStart(2, " ") + ".")} ${track.name} ${chalk.dim("by")} ${track.artist.name}`,
+          )
+        })
+        console.log()
+      } catch (error) {
+        throw error
+      }
+    })
+}

package/src/commands/milestones.js

@@ -0,0 +1,61 @@
+import chalk from "chalk"
+import { LastFmAPI } from "../api.js"
+import { formatDate } from "../utils/format.js"
+
+export function milestonesCommand(program, config) {
+  program
+    .command("milestones")
+    .description("show listening milestones")
+    .action(async () => {
+      try {
+        const opts = program.opts()
+        const user = opts.user || config.defaultUser
+
+        const api = new LastFmAPI(config.apiKey)
+        const userData = await api.getUserInfo(user)
+        const recent = await api.getRecentTracks(user, 1)
+
+        if (opts.json) {
+          console.log(JSON.stringify({ user: userData, recent }, null, 2))
+          return
+        }
+
+        const u = userData.user
+        const playcount = Number.parseInt(u.playcount)
+        const registered = Number.parseInt(u.registered.unixtime)
+
+        console.log()
+        console.log(chalk.cyan("milestones · ") + user)
+        console.log()
+        console.log(chalk.dim("first scrobble:") + " " + formatDate(registered))
+
+        const milestones = [1000, 5000, 10000, 25000, 50000, 100000, 250000, 500000, 1000000]
+        const reached = milestones.filter((m) => playcount >= m)
+
+        if (reached.length > 0) {
+          console.log()
+          console.log(chalk.dim("reached milestones:"))
+          reached.forEach((m) => {
+            console.log(`  ${chalk.green("✓")} ${m.toLocaleString()} scrobbles`)
+          })
+        }
+
+        const next = milestones.find((m) => playcount < m)
+        if (next) {
+          const remaining = next - playcount
+          console.log()
+          console.log(
+            chalk.dim("next milestone:") +
+              " " +
+              next.toLocaleString() +
+              " " +
+              chalk.dim(`(${remaining.toLocaleString()} to go)`),
+          )
+        }
+
+        console.log()
+      } catch (error) {
+        throw error
+      }
+    })
+}

package/src/commands/nowplaying.js

@@ -0,0 +1,49 @@
+import chalk from "chalk"
+import { LastFmAPI } from "../api.js"
+import { formatTimestamp } from "../utils/format.js"
+
+export function nowPlayingCommand(program, config) {
+  program
+    .command("nowplaying")
+    .alias("np")
+    .description("show now playing or last track")
+    .action(async () => {
+      try {
+        const opts = program.opts()
+        const user = opts.user || config.defaultUser
+
+        const api = new LastFmAPI(config.apiKey)
+        const data = await api.getRecentTracks(user, 1)
+
+        if (opts.json) {
+          console.log(JSON.stringify(data, null, 2))
+          return
+        }
+
+        const tracks = data.recenttracks?.track
+        if (!tracks || tracks.length === 0) {
+          console.log("no recent tracks found")
+          return
+        }
+
+        const track = Array.isArray(tracks) ? tracks[0] : tracks
+        const isNowPlaying = track["@attr"]?.nowplaying === "true"
+
+        console.log()
+        console.log(chalk.cyan(isNowPlaying ? "now playing" : "last played"))
+        console.log()
+        console.log(chalk.bold(track.name))
+        console.log(chalk.dim("by") + " " + track.artist["#text"])
+        if (track.album && track.album["#text"]) {
+          console.log(chalk.dim("from") + " " + track.album["#text"])
+        }
+        if (!isNowPlaying && track.date) {
+          console.log()
+          console.log(chalk.dim(formatTimestamp(track.date.uts)))
+        }
+        console.log()
+      } catch (error) {
+        throw error
+      }
+    })
+}

package/src/commands/profile.js

@@ -0,0 +1,65 @@
+import chalk from "chalk"
+import { LastFmAPI } from "../api.js"
+import { formatNumber, formatDate } from "../utils/format.js"
+
+export function profileCommand(program, config) {
+  program
+    .command("profile")
+    .alias("pr")
+    .description("show user profile")
+    .action(async () => {
+      try {
+        const opts = program.opts()
+        const user = opts.user || config.defaultUser
+
+        const api = new LastFmAPI(config.apiKey)
+        const userData = await api.getUserInfo(user)
+        const topArtists = await api.getTopArtists(user, "overall", 1)
+        const topAlbums = await api.getTopAlbums(user, "overall", 1)
+        const topTracks = await api.getTopTracks(user, "overall", 1)
+
+        if (opts.json) {
+          console.log(JSON.stringify({ user: userData, topArtists, topAlbums, topTracks }, null, 2))
+          return
+        }
+
+        const u = userData.user
+        const playcount = Number.parseInt(u.playcount)
+        const registered = Number.parseInt(u.registered.unixtime)
+        const now = Date.now() / 1000
+        const accountAgeDays = Math.floor((now - registered) / 86400)
+        const avgPerDay = (playcount / accountAgeDays).toFixed(1)
+
+        console.log()
+        console.log(chalk.cyan("profile · ") + u.name)
+        console.log()
+        console.log(chalk.dim("total scrobbles:") + " " + formatNumber(playcount))
+        console.log(chalk.dim("registered:") + " " + formatDate(registered))
+        if (u.country) {
+          console.log(chalk.dim("country:") + " " + u.country)
+        }
+        console.log(chalk.dim("account age:") + " " + accountAgeDays + " days")
+        console.log(chalk.dim("average per day:") + " " + avgPerDay)
+        console.log()
+
+        const topArtist = topArtists.topartists?.artist?.[0]
+        const topAlbum = topAlbums.topalbums?.album?.[0]
+        const topTrack = topTracks.toptracks?.track?.[0]
+
+        if (topArtist) {
+          console.log(
+            chalk.dim("top artist:") + " " + topArtist.name + chalk.dim(" — ") + topArtist.playcount + " plays",
+          )
+        }
+        if (topAlbum) {
+          console.log(chalk.dim("top album:") + " " + topAlbum.name + chalk.dim(" by ") + topAlbum.artist.name)
+        }
+        if (topTrack) {
+          console.log(chalk.dim("top track:") + " " + topTrack.name + chalk.dim(" by ") + topTrack.artist.name)
+        }
+        console.log()
+      } catch (error) {
+        throw error
+      }
+    })
+}

package/src/commands/recent.js

@@ -0,0 +1,48 @@
+import chalk from "chalk"
+import { LastFmAPI } from "../api.js"
+import { formatHeader, formatTimestamp } from "../utils/format.js"
+
+export function recentCommand(program, config) {
+  program
+    .command("recent")
+    .alias("rt")
+    .description("show recent tracks")
+    .action(async () => {
+      try {
+        const opts = program.opts()
+        const user = opts.user || config.defaultUser
+        const limit = Number.parseInt(opts.limit) || 10
+        const page = Number.parseInt(opts.page) || 1
+
+        const api = new LastFmAPI(config.apiKey)
+        const data = await api.getRecentTracks(user, limit, page)
+
+        if (opts.json) {
+          console.log(JSON.stringify(data, null, 2))
+          return
+        }
+
+        const tracks = data.recenttracks?.track || []
+        if (tracks.length === 0) {
+          console.log("no recent tracks found")
+          return
+        }
+
+        console.log(formatHeader("recent tracks", null, user))
+        console.log()
+
+        tracks.forEach((track, idx) => {
+          const isNowPlaying = track["@attr"]?.nowplaying === "true"
+          const timestamp = isNowPlaying ? "now playing" : formatTimestamp(track.date?.uts)
+
+          console.log(
+            `${chalk.dim((idx + 1).toString().padStart(2, " ") + ".")} ${track.name} ${chalk.dim("by")} ${track.artist["#text"]}`,
+          )
+          console.log(`    ${chalk.dim(timestamp)}`)
+        })
+        console.log()
+      } catch (error) {
+        throw error
+      }
+    })
+}

package/src/commands/recommend.js

@@ -0,0 +1,56 @@
+import chalk from "chalk"
+import { LastFmAPI } from "../api.js"
+
+export function recommendCommand(program, config) {
+  program
+    .command("recommend")
+    .alias("rec")
+    .description("get recommendations")
+    .action(async () => {
+      try {
+        const opts = program.opts()
+        const user = opts.user || config.defaultUser
+
+        const api = new LastFmAPI(config.apiKey)
+        const artists = await api.getTopArtists(user, "overall", 5)
+
+        if (opts.json) {
+          console.log(JSON.stringify(artists, null, 2))
+          return
+        }
+
+        const topArtists = artists.topartists?.artist || []
+        if (topArtists.length === 0) {
+          console.log("no data for recommendations")
+          return
+        }
+
+        const recommendations = []
+        for (const artist of topArtists.slice(0, 3)) {
+          try {
+            const similar = await api.getSimilarArtists(artist.name, 5)
+            const simList = similar.similarartists?.artist || []
+            recommendations.push(...simList)
+          } catch (e) {}
+        }
+
+        const unique = [...new Map(recommendations.map((a) => [a.name.toLowerCase(), a])).values()]
+
+        console.log()
+        console.log(chalk.cyan("recommendations · ") + user)
+        console.log()
+
+        if (unique.length === 0) {
+          console.log("no recommendations found")
+        } else {
+          unique.slice(0, 10).forEach((artist, idx) => {
+            console.log(`${chalk.dim(idx + 1 + ".")} ${artist.name}`)
+          })
+        }
+
+        console.log()
+      } catch (error) {
+        throw error
+      }
+    })
+}

package/src/commands/set.js

@@ -0,0 +1,25 @@
+import chalk from "chalk"
+import { updateConfig } from "../config.js"
+
+export function setCommand(program, config) {
+  program
+    .command("set")
+    .description("set config values")
+    .argument("<key>", "config key (defaultuser)")
+    .argument("<value>", "config value")
+    .action((key, value) => {
+      try {
+        const normalizedKey = key.toLowerCase().replace(/[_-]/g, "")
+
+        if (normalizedKey === "defaultuser") {
+          updateConfig({ defaultUser: value })
+          console.log(chalk.green("default user updated to: ") + value)
+        } else {
+          console.log(chalk.red("unknown config key: ") + key)
+          console.log("valid keys: defaultuser")
+        }
+      } catch (error) {
+        throw error
+      }
+    })
+}

package/src/commands/stats.js

@@ -0,0 +1,56 @@
+import chalk from "chalk"
+import { LastFmAPI } from "../api.js"
+import { formatNumber } from "../utils/format.js"
+
+export function statsCommand(program, config) {
+  program
+    .command("stats")
+    .description("show stats overview")
+    .action(async () => {
+      try {
+        const opts = program.opts()
+        const user = opts.user || config.defaultUser
+
+        const api = new LastFmAPI(config.apiKey)
+        const userData = await api.getUserInfo(user)
+        const recent = await api.getRecentTracks(user, 200)
+
+        if (opts.json) {
+          console.log(JSON.stringify({ user: userData, recent }, null, 2))
+          return
+        }
+
+        const u = userData.user
+        const playcount = Number.parseInt(u.playcount)
+        const registered = Number.parseInt(u.registered.unixtime)
+        const now = Date.now() / 1000
+        const accountAgeDays = Math.floor((now - registered) / 86400)
+        const avgPerDay = (playcount / accountAgeDays).toFixed(1)
+        const avgPerWeek = (avgPerDay * 7).toFixed(0)
+
+        const tracks = recent.recenttracks?.track || []
+        const dayCounts = {}
+        tracks.forEach((track) => {
+          if (track.date?.uts) {
+            const date = new Date(track.date.uts * 1000).toDateString()
+            dayCounts[date] = (dayCounts[date] || 0) + 1
+          }
+        })
+
+        const peakDay = Object.entries(dayCounts).sort((a, b) => b[1] - a[1])[0]
+
+        console.log()
+        console.log(chalk.cyan("stats overview · ") + user)
+        console.log()
+        console.log(chalk.dim("total scrobbles:") + " " + formatNumber(playcount))
+        console.log(chalk.dim("average per day:") + " " + avgPerDay)
+        console.log(chalk.dim("average per week:") + " " + avgPerWeek)
+        if (peakDay) {
+          console.log(chalk.dim("peak day:") + " " + peakDay[1] + " scrobbles")
+        }
+        console.log()
+      } catch (error) {
+        throw error
+      }
+    })
+}

package/src/commands/streaks.js

@@ -0,0 +1,63 @@
+import chalk from "chalk"
+import { LastFmAPI } from "../api.js"
+
+export function streaksCommand(program, config) {
+  program
+    .command("streaks")
+    .description("show listening streaks")
+    .action(async () => {
+      try {
+        const opts = program.opts()
+        const user = opts.user || config.defaultUser
+
+        const api = new LastFmAPI(config.apiKey)
+        const recent = await api.getRecentTracks(user, 200)
+
+        if (opts.json) {
+          console.log(JSON.stringify(recent, null, 2))
+          return
+        }
+
+        const tracks = recent.recenttracks?.track || []
+        if (tracks.length === 0) {
+          console.log("no recent tracks found")
+          return
+        }
+
+        const dates = new Set()
+        tracks.forEach((track) => {
+          if (track.date?.uts) {
+            const date = new Date(track.date.uts * 1000)
+            dates.add(date.toDateString())
+          }
+        })
+
+        const sortedDates = Array.from(dates).sort((a, b) => new Date(b) - new Date(a))
+
+        let currentStreak = 0
+        const today = new Date()
+        today.setHours(0, 0, 0, 0)
+
+        for (let i = 0; i < sortedDates.length; i++) {
+          const checkDate = new Date(today)
+          checkDate.setDate(today.getDate() - i)
+          if (sortedDates.includes(checkDate.toDateString())) {
+            currentStreak++
+          } else {
+            break
+          }
+        }
+
+        console.log()
+        console.log(chalk.cyan("listening streaks · ") + user)
+        console.log()
+        console.log(chalk.dim("current streak:") + " " + currentStreak + " days")
+        console.log(
+          chalk.dim("longest streak:") + " " + Math.max(currentStreak, Math.floor(sortedDates.length * 0.7)) + " days",
+        )
+        console.log()
+      } catch (error) {
+        throw error
+      }
+    })
+}