@involvex/youtube-music-cli 0.0.11 → 0.0.13

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.0.13](https://github.com/involvex/youtube-music-cli/compare/v0.0.12...v0.0.13) (2026-02-18)
+
+### Features
+
+- **download:** add cover art and improved file organization ([1d48f7d](https://github.com/involvex/youtube-music-cli/commit/1d48f7de3a4787e9341697b4c6f44a50a43e752c))
+
+### BREAKING CHANGES
+
+- **download:** The output file structure has changed from flat directory
+  to nested artist/album directories. Existing workflows expecting the old
+  structure will need to be updated.
+
+## [0.0.12](https://github.com/involvex/youtube-music-cli/compare/v0.0.11...v0.0.12) (2026-02-18)
+
 ## [0.0.11](https://github.com/involvex/youtube-music-cli/compare/v0.0.10...v0.0.11) (2026-02-18)
 
 ### Features

package/dist/source/components/playlist/PlaylistList.js

@@ -22,6 +22,7 @@ export default function PlaylistList() {
     const [renamingPlaylistId, setRenamingPlaylistId] = useState(null);
     const [renameValue, setRenameValue] = useState('');
     const [downloadStatus, setDownloadStatus] = useState(null);
+    const [isDownloading, setIsDownloading] = useState(false);
     useKeyboardBlocker(renamingPlaylistId !== null);
     const handleCreate = useCallback(() => {
         const name = `Playlist ${playlists.length + 1}`;
@@ -82,6 +83,10 @@ export default function PlaylistList() {
     const handleDownload = useCallback(async () => {
         if (renamingPlaylistId)
             return;
+        if (isDownloading) {
+            setDownloadStatus('Download already in progress. Please wait.');
+            return;
+        }
         const playlist = playlists[selectedIndex];
         if (!playlist)
             return;
@@ -95,15 +100,25 @@ export default function PlaylistList() {
             setDownloadStatus(`No tracks to download in "${playlist.name}".`);
             return;
         }
-        setDownloadStatus(`Downloading ${target.tracks.length} track(s) from "${playlist.name}"...`);
+        setDownloadStatus(`Downloading ${target.tracks.length} track(s) from "${playlist.name}"... this can take a few minutes.`);
         try {
+            setIsDownloading(true);
             const summary = await downloadService.downloadTracks(target.tracks);
             setDownloadStatus(`Downloaded ${summary.downloaded}, skipped ${summary.skipped}, failed ${summary.failed}.`);
         }
         catch (error) {
             setDownloadStatus(error instanceof Error ? error.message : 'Failed to download playlist.');
         }
-    }, [downloadService, playlists, renamingPlaylistId, selectedIndex]);
+        finally {
+            setIsDownloading(false);
+        }
+    }, [
+        downloadService,
+        isDownloading,
+        playlists,
+        renamingPlaylistId,
+        selectedIndex,
+    ]);
     useKeyBinding(KEYBINDINGS.UP, navigateUp);
     useKeyBinding(KEYBINDINGS.DOWN, navigateDown);
     useKeyBinding(KEYBINDINGS.SELECT, startPlaylist);

package/dist/source/components/search/SearchResults.js

@@ -9,7 +9,7 @@ import { usePlayer } from "../../hooks/usePlayer.js";
 import { usePlaylist } from "../../hooks/usePlaylist.js";
 import { KEYBINDINGS, VIEW } from "../../utils/constants.js";
 import { truncate } from "../../utils/format.js";
-import { useCallback, useRef, useEffect } from 'react';
+import { useCallback, useRef, useEffect, useState } from 'react';
 import { logger } from "../../services/logger/logger.service.js";
 import { useTerminalSize } from "../../hooks/useTerminalSize.js";
 import { getMusicService } from "../../services/youtube-music/api.js";
@@ -24,6 +24,7 @@ function SearchResults({ results, selectedIndex, isActive = true, onMixCreated,
     const musicService = getMusicService();
     const downloadService = getDownloadService();
     const { createPlaylist } = usePlaylist();
+    const [isDownloading, setIsDownloading] = useState(false);
     const mixCreatedRef = useRef(onMixCreated);
     mixCreatedRef.current = onMixCreated;
     const downloadStatusRef = useRef(onDownloadStatus);
@@ -225,6 +226,10 @@ function SearchResults({ results, selectedIndex, isActive = true, onMixCreated,
     const downloadSelected = useCallback(async () => {
         if (!isActive)
             return;
+        if (isDownloading) {
+            downloadStatusRef.current?.('Download already in progress. Please wait.');
+            return;
+        }
         const selected = results[selectedIndex];
         if (!selected)
             return;
@@ -234,19 +239,23 @@ function SearchResults({ results, selectedIndex, isActive = true, onMixCreated,
             return;
         }
         try {
+            setIsDownloading(true);
             const target = await downloadService.resolveSearchTarget(selected);
             if (target.tracks.length === 0) {
                 downloadStatusRef.current?.(`No tracks found for "${target.name}".`);
                 return;
             }
-            downloadStatusRef.current?.(`Downloading ${target.tracks.length} track(s) from "${target.name}"...`);
+            downloadStatusRef.current?.(`Downloading ${target.tracks.length} track(s) from "${target.name}"... this can take a few minutes.`);
             const summary = await downloadService.downloadTracks(target.tracks);
             downloadStatusRef.current?.(`Downloaded ${summary.downloaded}, skipped ${summary.skipped}, failed ${summary.failed}.`);
         }
         catch (error) {
             downloadStatusRef.current?.(error instanceof Error ? error.message : 'Download failed.');
         }
-    }, [downloadService, isActive, results, selectedIndex]);
+        finally {
+            setIsDownloading(false);
+        }
+    }, [downloadService, isActive, isDownloading, results, selectedIndex]);
     useKeyBinding(KEYBINDINGS.UP, navigateUp);
     useKeyBinding(KEYBINDINGS.DOWN, navigateDown);
     useKeyBinding(KEYBINDINGS.SELECT, handleSelect);

package/dist/source/services/download/download.service.d.ts

@@ -13,6 +13,7 @@ type DownloadTarget = {
 declare class DownloadService {
     private ffmpegChecked;
     private ffmpegAvailable;
+    private activeDownload;
     private readonly config;
     private readonly musicService;
     getConfig(): {
@@ -29,7 +30,11 @@ declare class DownloadService {
     private fetchAudio;
     private ensureFfmpeg;
     private convertAudio;
+    private buildMetadataArgs;
     private runFfmpeg;
+    private recordViaYtDlp;
+    private downloadCoverArt;
+    private recordViaMpv;
 }
 export declare function getDownloadService(): DownloadService;
 export {};

package/dist/source/services/download/download.service.js

@@ -7,6 +7,7 @@ import { getMusicService } from "../youtube-music/api.js";
 class DownloadService {
     ffmpegChecked = false;
     ffmpegAvailable = false;
+    activeDownload = false;
     config = getConfigService();
     musicService = getMusicService();
     getConfig() {
@@ -55,49 +56,97 @@ class DownloadService {
         };
     }
     async downloadTracks(tracks) {
+        if (this.activeDownload) {
+            throw new Error('A download is already in progress. Please wait for it to finish.');
+        }
         const { directory, format } = this.getConfig();
         if (!directory) {
             throw new Error('No download directory configured.');
         }
         mkdirSync(directory, { recursive: true });
         await this.ensureFfmpeg();
+        this.activeDownload = true;
         const result = {
             downloaded: 0,
             skipped: 0,
             failed: 0,
             errors: [],
         };
-        for (const track of tracks) {
-            const destination = this.getDestinationPath(track, directory, format);
-            const tempSource = `${destination}.source`;
-            try {
-                if (existsSync(destination)) {
-                    result.skipped++;
-                    continue;
+        try {
+            for (const track of tracks) {
+                const destination = this.getDestinationPath(track, directory, format);
+                const tempSource = `${destination}.source`;
+                const tempCover = `${destination}.cover.jpg`;
+                try {
+                    logger.info('DownloadService', 'Starting track download', {
+                        videoId: track.videoId,
+                        title: track.title,
+                    });
+                    mkdirSync(path.dirname(destination), { recursive: true });
+                    if (existsSync(destination)) {
+                        result.skipped++;
+                        logger.debug('DownloadService', 'Skipping existing file', {
+                            destination,
+                        });
+                        continue;
+                    }
+                    try {
+                        const streamUrl = await this.musicService.getStreamUrl(track.videoId);
+                        const audioBuffer = await this.fetchAudio(streamUrl);
+                        writeFileSync(tempSource, audioBuffer);
+                    }
+                    catch (streamError) {
+                        logger.warn('DownloadService', 'Stream URL extraction failed, falling back to yt-dlp', {
+                            videoId: track.videoId,
+                            error: streamError instanceof Error
+                                ? streamError.message
+                                : String(streamError),
+                        });
+                        try {
+                            await this.recordViaYtDlp(track.videoId, tempSource);
+                        }
+                        catch (ytdlpError) {
+                            logger.warn('DownloadService', 'yt-dlp fallback failed, falling back to mpv recording', {
+                                videoId: track.videoId,
+                                error: ytdlpError instanceof Error
+                                    ? ytdlpError.message
+                                    : String(ytdlpError),
+                            });
+                            await this.recordViaMpv(track.videoId, tempSource);
+                        }
+                    }
+                    const hasCover = await this.downloadCoverArt(track.videoId, tempCover);
+                    await this.convertAudio(tempSource, destination, format, track, hasCover ? tempCover : undefined);
+                    result.downloaded++;
+                    logger.info('DownloadService', 'Track download complete', {
+                        videoId: track.videoId,
+                        destination,
+                    });
                 }
-                const streamUrl = await this.musicService.getStreamUrl(track.videoId);
-                const audioBuffer = await this.fetchAudio(streamUrl);
-                writeFileSync(tempSource, audioBuffer);
-                await this.convertAudio(tempSource, destination, format);
-                result.downloaded++;
-            }
-            catch (error) {
-                result.failed++;
-                const message = error instanceof Error ? error.message : 'Unknown download failure';
-                result.errors.push(message);
-                logger.error('DownloadService', 'Track download failed', {
-                    videoId: track.videoId,
-                    title: track.title,
-                    error: message,
-                });
-            }
-            finally {
-                if (existsSync(tempSource)) {
-                    unlinkSync(tempSource);
+                catch (error) {
+                    result.failed++;
+                    const message = error instanceof Error ? error.message : 'Unknown download failure';
+                    result.errors.push(message);
+                    logger.error('DownloadService', 'Track download failed', {
+                        videoId: track.videoId,
+                        title: track.title,
+                        error: message,
+                    });
+                }
+                finally {
+                    if (existsSync(tempSource)) {
+                        unlinkSync(tempSource);
+                    }
+                    if (existsSync(tempCover)) {
+                        unlinkSync(tempCover);
+                    }
                 }
             }
+            return result;
+        }
+        finally {
+            this.activeDownload = false;
         }
-        return result;
     }
     uniqueTracks(tracks) {
         const seen = new Set();
@@ -112,8 +161,11 @@ class DownloadService {
     }
     getDestinationPath(track, directory, format) {
         const artist = track.artists[0]?.name ?? 'Unknown Artist';
-        const baseName = this.sanitizeFilename(`${artist} - ${track.title}`);
-        return path.join(directory, `${baseName}.${format}`);
+        const album = track.album?.name ?? 'Singles';
+        const artistDir = this.sanitizeFilename(artist) || 'Unknown Artist';
+        const albumDir = this.sanitizeFilename(album) || 'Singles';
+        const fileName = this.sanitizeFilename(track.title) || track.videoId;
+        return path.join(directory, artistDir, albumDir, `${fileName}.${format}`);
     }
     sanitizeFilename(value) {
         return value.replace(/[<>:"/\\|?*\u0000-\u001F]/g, '_').trim();
@@ -143,32 +195,52 @@ class DownloadService {
             throw new Error('ffmpeg is required for downloads. Install ffmpeg and ensure it is available in PATH.');
         }
     }
-    async convertAudio(sourcePath, destinationPath, format) {
+    async convertAudio(sourcePath, destinationPath, format, track, coverPath) {
+        const metadataArgs = this.buildMetadataArgs(track);
         if (format === 'mp3') {
-            await this.runFfmpeg([
-                '-y',
-                '-i',
-                sourcePath,
-                '-vn',
-                '-codec:a',
-                'libmp3lame',
-                '-q:a',
-                '2',
-                destinationPath,
-            ]);
+            const args = ['-y', '-i', sourcePath];
+            if (coverPath) {
+                args.push('-i', coverPath, '-map', '0:a:0', '-map', '1:v:0');
+            }
+            else {
+                args.push('-map', '0:a:0', '-vn');
+            }
+            args.push('-codec:a', 'libmp3lame', '-q:a', '2', ...metadataArgs);
+            if (coverPath) {
+                args.push('-codec:v', 'mjpeg', '-disposition:v:0', 'attached_pic', '-metadata:s:v', 'title=Album cover', '-metadata:s:v', 'comment=Cover (front)');
+            }
+            args.push(destinationPath);
+            await this.runFfmpeg(args);
             return;
         }
-        await this.runFfmpeg([
-            '-y',
-            '-i',
-            sourcePath,
-            '-vn',
-            '-codec:a',
-            'aac',
-            '-b:a',
-            '192k',
-            destinationPath,
-        ]);
+        const args = ['-y', '-i', sourcePath];
+        if (coverPath) {
+            args.push('-i', coverPath, '-map', '0:a:0', '-map', '1:v:0');
+        }
+        else {
+            args.push('-map', '0:a:0', '-vn');
+        }
+        args.push('-codec:a', 'aac', '-b:a', '192k', ...metadataArgs);
+        if (coverPath) {
+            args.push('-codec:v', 'mjpeg', '-disposition:v:0', 'attached_pic');
+        }
+        args.push(destinationPath);
+        await this.runFfmpeg(args);
+    }
+    buildMetadataArgs(track) {
+        const artist = track.artists
+            .map(row => row.name)
+            .filter(Boolean)
+            .join(', ') || 'Unknown Artist';
+        const album = track.album?.name || 'Singles';
+        return [
+            '-metadata',
+            `title=${track.title}`,
+            '-metadata',
+            `artist=${artist}`,
+            '-metadata',
+            `album=${album}`,
+        ];
     }
     async runFfmpeg(args) {
         await new Promise((resolve, reject) => {
@@ -187,6 +259,87 @@ class DownloadService {
             });
         });
     }
+    async recordViaYtDlp(videoId, outputPath) {
+        const watchUrl = `https://www.youtube.com/watch?v=${videoId}`;
+        await new Promise((resolve, reject) => {
+            const process = spawn('yt-dlp', [
+                '--no-playlist',
+                '--quiet',
+                '--no-warnings',
+                '--js-runtimes',
+                'node',
+                '-f',
+                'bestaudio',
+                '--output',
+                outputPath,
+                watchUrl,
+            ], { windowsHide: true });
+            let stderr = '';
+            let stdout = '';
+            process.stderr.on('data', chunk => {
+                stderr += String(chunk);
+            });
+            process.stdout.on('data', chunk => {
+                stdout += String(chunk);
+            });
+            process.on('error', reject);
+            process.on('exit', code => {
+                if (code === 0 && existsSync(outputPath)) {
+                    resolve();
+                    return;
+                }
+                reject(new Error((stderr || stdout).trim() ||
+                    `yt-dlp exited with code ${code} and no output file`));
+            });
+        });
+    }
+    async downloadCoverArt(videoId, outputPath) {
+        const candidates = [
+            `https://i.ytimg.com/vi/${videoId}/maxresdefault.jpg`,
+            `https://i.ytimg.com/vi/${videoId}/hqdefault.jpg`,
+        ];
+        for (const url of candidates) {
+            try {
+                const response = await fetch(url);
+                if (!response.ok)
+                    continue;
+                const image = Buffer.from(await response.arrayBuffer());
+                if (image.length === 0)
+                    continue;
+                writeFileSync(outputPath, image);
+                return true;
+            }
+            catch {
+                continue;
+            }
+        }
+        return false;
+    }
+    async recordViaMpv(videoId, outputPath) {
+        const watchUrl = `https://www.youtube.com/watch?v=${videoId}`;
+        await new Promise((resolve, reject) => {
+            const process = spawn('mpv', [
+                watchUrl,
+                '--no-video',
+                '--ao=null',
+                '--ytdl=yes',
+                '--really-quiet',
+                `--stream-record=${outputPath}`,
+            ], { windowsHide: true });
+            let stderr = '';
+            process.stderr.on('data', chunk => {
+                stderr += String(chunk);
+            });
+            process.on('error', reject);
+            process.on('exit', code => {
+                if (code === 0 && existsSync(outputPath)) {
+                    resolve();
+                    return;
+                }
+                reject(new Error(stderr.trim() || `mpv exited with code ${code} and no output file`));
+            });
+        });
+    }
 }
 let downloadServiceInstance = null;
 export function getDownloadService() {

package/dist/source/services/youtube-music/api.js

@@ -295,119 +295,52 @@ class MusicService {
     }
     async getStreamUrl(videoId) {
         logger.info('MusicService', 'Starting stream extraction', { videoId });
-        // Try Method 1: @distube/ytdl-core (most reliable, actively maintained)
-        try {
-            logger.debug('MusicService', 'Attempting ytdl-core extraction', {
-                videoId,
-            });
-            const ytdl = await import('@distube/ytdl-core');
-            const videoUrl = `https://www.youtube.com/watch?v=${videoId}`;
-            const info = await ytdl.default.getInfo(videoUrl);
-            logger.debug('MusicService', 'ytdl-core getInfo succeeded', {
-                formatCount: info.formats.length,
-            });
-            const audioFormats = ytdl.default.filterFormats(info.formats, 'audioonly');
-            logger.debug('MusicService', 'ytdl-core audio formats filtered', {
-                audioFormatCount: audioFormats.length,
-            });
-            if (audioFormats.length > 0) {
-                // Get highest quality audio
-                const bestAudio = audioFormats.sort((a, b) => {
-                    const aBitrate = Number.parseInt(String(a.audioBitrate || 0));
-                    const bBitrate = Number.parseInt(String(b.audioBitrate || 0));
-                    return bBitrate - aBitrate;
-                })[0];
-                if (bestAudio?.url) {
-                    logger.info('MusicService', 'Using ytdl-core stream', {
-                        bitrate: bestAudio.audioBitrate,
-                        urlLength: bestAudio.url.length,
-                        mimeType: bestAudio.mimeType,
-                    });
-                    return bestAudio.url;
-                }
-            }
-            logger.warn('MusicService', 'ytdl-core: No audio formats with URL found');
-        }
-        catch (error) {
-            logger.error('MusicService', 'ytdl-core extraction failed', {
-                error: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? error.stack : undefined,
-            });
+        const isBunRuntime = typeof globalThis.Bun !== 'undefined';
+        // Try Method 1: @distube/ytdl-core (skip under Bun due undici incompatibility)
+        if (isBunRuntime) {
+            logger.warn('MusicService', 'Skipping ytdl-core extraction on Bun runtime', { videoId });
         }
-        // Try Method 2: youtubei.js (may fail with ParsingError)
-        try {
-            logger.debug('MusicService', 'Attempting youtubei.js extraction', {
-                videoId,
-            });
-            const yt = await getClient();
-            const video = (await yt.getInfo(videoId));
-            logger.debug('MusicService', 'youtubei.js getInfo succeeded');
-            // Get the download URL for the video
-            const streamData = video.chooseFormat?.({
-                type: 'audio',
-                quality: 'best',
-            });
-            if (streamData?.url) {
-                logger.info('MusicService', 'Using youtubei.js stream (chooseFormat)', {
-                    urlLength: streamData.url.length,
+        else {
+            try {
+                logger.debug('MusicService', 'Attempting ytdl-core extraction', {
+                    videoId,
                 });
-                return streamData.url;
-            }
-            // Fallback: Manually select from streaming_data.adaptive_formats
-            logger.debug('MusicService', 'chooseFormat returned nothing, trying manual selection');
-            const streamingData = video.streaming_data;
-            if (streamingData?.adaptive_formats) {
-                logger.debug('MusicService', 'Found adaptive_formats', {
-                    count: streamingData.adaptive_formats.length,
+                const ytdl = await import('@distube/ytdl-core');
+                const videoUrl = `https://www.youtube.com/watch?v=${videoId}`;
+                const info = await ytdl.default.getInfo(videoUrl);
+                logger.debug('MusicService', 'ytdl-core getInfo succeeded', {
+                    formatCount: info.formats.length,
                 });
-                // Filter for audio-only formats
-                const audioFormats = streamingData.adaptive_formats.filter((f) => f.mime_type?.includes('audio') || f.type?.includes('audio'));
-                logger.debug('MusicService', 'Audio formats found', {
-                    count: audioFormats.length,
+                const audioFormats = ytdl.default.filterFormats(info.formats, 'audioonly');
+                logger.debug('MusicService', 'ytdl-core audio formats filtered', {
+                    audioFormatCount: audioFormats.length,
                 });
                 if (audioFormats.length > 0) {
-                    // Sort by bitrate (higher is better)
-                    const sorted = audioFormats.sort((a, b) => {
-                        const aBitrate = Number.parseInt(String(a.bitrate || 0));
-                        const bBitrate = Number.parseInt(String(b.bitrate || 0));
+                    // Get highest quality audio
+                    const bestAudio = audioFormats.sort((a, b) => {
+                        const aBitrate = Number.parseInt(String(a.audioBitrate || 0));
+                        const bBitrate = Number.parseInt(String(b.audioBitrate || 0));
                         return bBitrate - aBitrate;
-                    });
-                    const bestAudio = sorted[0];
-                    if (bestAudio) {
-                        // Check for direct URL
-                        if (bestAudio.url) {
-                            logger.info('MusicService', 'Using youtubei.js stream (manual)', {
-                                bitrate: bestAudio.bitrate,
-                                mimeType: bestAudio.mime_type || bestAudio.type,
-                                urlLength: bestAudio.url.length,
-                            });
-                            return bestAudio.url;
-                        }
-                        // Check for signatureCipher (needs decoding)
-                        if (bestAudio.signature_cipher || bestAudio.signatureCipher) {
-                            logger.warn('MusicService', 'Format has signature cipher (not supported)', {
-                                hasCipher: true,
-                            });
-                        }
+                    })[0];
+                    if (bestAudio?.url) {
+                        logger.info('MusicService', 'Using ytdl-core stream', {
+                            bitrate: bestAudio.audioBitrate,
+                            urlLength: bestAudio.url.length,
+                            mimeType: bestAudio.mimeType,
+                        });
+                        return bestAudio.url;
                     }
                 }
+                logger.warn('MusicService', 'ytdl-core: No audio formats with URL found');
             }
-            logger.warn('MusicService', 'youtubei.js: No usable stream URL found');
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('ParsingError')) {
-                logger.warn('MusicService', 'youtubei.js parsing error (expected)', {
-                    error: error.message,
-                });
-            }
-            else {
-                logger.error('MusicService', 'youtubei.js extraction failed', {
+            catch (error) {
+                logger.error('MusicService', 'ytdl-core extraction failed', {
                     error: error instanceof Error ? error.message : String(error),
                     stack: error instanceof Error ? error.stack : undefined,
                 });
             }
         }
-        // Try Method 3: youtube-ext (lightweight, no parsing needed)
+        // Try Method 2: youtube-ext (lightweight, no parser path)
         try {
             logger.debug('MusicService', 'Attempting youtube-ext extraction', {
                 videoId,
@@ -445,7 +378,7 @@ class MusicService {
                 stack: error instanceof Error ? error.stack : undefined,
             });
         }
-        // Try Method 4: Invidious API (last resort)
+        // Try Method 3: Invidious API (last resort)
         try {
             logger.debug('MusicService', 'Attempting Invidious extraction', {
                 videoId,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@involvex/youtube-music-cli",
-	"version": "0.0.11",
+	"version": "0.0.13",
 	"description": "- A Commandline music player for youtube-music",
 	"repository": {
 		"type": "git",
@@ -47,20 +47,12 @@
 		"lint": "eslint . --ext .js,.jsx,.ts,.tsx --ignore-pattern dist",
 		"lint:fix": "eslint . --ext .js,.jsx,.ts,.tsx --fix --ignore-pattern dist",
 		"start": "bun run dist/source/cli.js",
-		"test": "prettier --check . && bun run lint && ava",
+		"test": "bun run build && ava",
 		"typecheck": "tsc --noEmit",
 		"changelog": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
 		"clean": "rimraf dist",
 		"release": "powershell -File scripts/release.ps1"
 	},
-	"xo": {
-		"react": true,
-		"prettier": true,
-		"rules": {
-			"react/prop-types": "off"
-		},
-		"semicolon": true
-	},
 	"prettier": "@vdemedes/prettier-config",
 	"ava": {
 		"files": [
@@ -93,7 +85,6 @@
 		"chalk": "^5.6.2",
 		"conventional-changelog-cli": "^5.0.0",
 		"eslint": "^10.0.0",
-		"eslint-config-xo-react": "^0.29.0",
 		"eslint-plugin-react": "^7.37.5",
 		"eslint-plugin-react-hooks": "^7.0.1",
 		"globals": "^17.3.0",
@@ -106,8 +97,7 @@
 		"rimraf": "^6.1.3",
 		"ts-node": "^10.9.2",
 		"typescript": "^5.9.3",
-		"typescript-eslint": "^8.56.0",
-		"xo": "^1.2.3"
+		"typescript-eslint": "^8.56.0"
 	},
 	"engines": {
 		"node": ">=16"