@involvex/youtube-music-cli 0.0.8 → 0.0.9

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.0.9](https://github.com/involvex/youtube-music-cli/compare/v0.0.8...v0.0.9) (2026-02-18)
+
+### Features
+
+- **search:** add dynamic mix creation from search results ([0d50231](https://github.com/involvex/youtube-music-cli/commit/0d5023168c73cec9d22dab9808e0fb2f23b5c1cc))
+
 ## [0.0.8](https://github.com/involvex/youtube-music-cli/compare/v0.0.7...v0.0.8) (2026-02-18)
 
 ### Features

package/dist/source/components/layouts/SearchLayout.js

@@ -3,7 +3,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useNavigation } from "../../hooks/useNavigation.js";
 import { useYouTubeMusic } from "../../hooks/useYouTubeMusic.js";
 import SearchResults from "../search/SearchResults.js";
-import { useState, useCallback, useEffect } from 'react';
+import { useState, useCallback, useEffect, useRef } from 'react';
 import React from 'react';
 import { useTheme } from "../../hooks/useTheme.js";
 import SearchBar from "../search/SearchBar.js";
@@ -17,6 +17,8 @@ function SearchLayout() {
     const [results, setResults] = useState([]);
     const [isTyping, setIsTyping] = useState(true);
     const [isSearching, setIsSearching] = useState(false);
+    const [mixMessage, setMixMessage] = useState(null);
+    const mixTimeoutRef = useRef(null);
     // Handle search action
     const performSearch = useCallback(async (query) => {
         if (!query || isSearching)
@@ -71,6 +73,23 @@ function SearchLayout() {
         }
     }, [isTyping, dispatch]);
     useKeyBinding(KEYBINDINGS.BACK, goBack);
+    const handleMixCreated = useCallback((message) => {
+        setMixMessage(message);
+        if (mixTimeoutRef.current) {
+            clearTimeout(mixTimeoutRef.current);
+        }
+        mixTimeoutRef.current = setTimeout(() => {
+            setMixMessage(null);
+            mixTimeoutRef.current = null;
+        }, 4000);
+    }, []);
+    useEffect(() => {
+        return () => {
+            if (mixTimeoutRef.current) {
+                clearTimeout(mixTimeoutRef.current);
+            }
+        };
+    }, []);
     // Reset search state when leaving view
     useEffect(() => {
         return () => {
@@ -81,8 +100,8 @@ function SearchLayout() {
     }, [dispatch]);
     return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { borderStyle: "single", borderColor: theme.colors.secondary, paddingX: 1, children: [_jsx(Text, { bold: true, color: theme.colors.primary, children: "Search" }), _jsxs(Text, { color: theme.colors.dim, children: [' ', "| Limit: ", navState.searchLimit, " (Use [ or ] to adjust)"] })] }), _jsx(SearchBar, { isActive: isTyping && !isSearching, onInput: input => {
                     void performSearch(input);
-                } }), (isLoading || isSearching) && (_jsx(Text, { color: theme.colors.accent, children: "Searching..." })), error && _jsx(Text, { color: theme.colors.error, children: error }), !isLoading && navState.hasSearched && (_jsx(SearchResults, { results: results, selectedIndex: navState.selectedResult, isActive: !isTyping })), !isLoading && navState.hasSearched && results.length === 0 && !error && (_jsx(Text, { color: theme.colors.dim, children: "No results found" })), _jsx(Text, { color: theme.colors.dim, children: isTyping
+                } }), (isLoading || isSearching) && (_jsx(Text, { color: theme.colors.accent, children: "Searching..." })), error && _jsx(Text, { color: theme.colors.error, children: error }), !isLoading && navState.hasSearched && (_jsx(SearchResults, { results: results, selectedIndex: navState.selectedResult, isActive: !isTyping, onMixCreated: handleMixCreated })), !isLoading && navState.hasSearched && results.length === 0 && !error && (_jsx(Text, { color: theme.colors.dim, children: "No results found" })), mixMessage && _jsx(Text, { color: theme.colors.accent, children: mixMessage }), _jsx(Text, { color: theme.colors.dim, children: isTyping
                     ? 'Type to search, Enter to start, Esc to clear'
-                    : `Arrows to navigate, Enter to play, ]/[ more/fewer results (${navState.searchLimit}), H for history, Esc to type` })] }));
+                    : `Arrows to navigate, Enter to play, M to create mix, ]/[ more/fewer results (${navState.searchLimit}), H for history, Esc to type` })] }));
 }
 export default React.memo(SearchLayout);

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

@@ -22,8 +22,8 @@ export default function PlaylistList() {
     useKeyboardBlocker(renamingPlaylistId !== null);
     const handleCreate = useCallback(() => {
         const name = `Playlist ${playlists.length + 1}`;
-        createPlaylist(name);
-        setLastCreated(name);
+        const playlist = createPlaylist(name);
+        setLastCreated(playlist.name);
         setSelectedIndex(playlists.length);
     }, [createPlaylist, playlists.length]);
     const navigateUp = useCallback(() => {

package/dist/source/components/search/SearchResults.d.ts

@@ -4,7 +4,8 @@ type Props = {
     results: SearchResult[];
     selectedIndex: number;
     isActive?: boolean;
+    onMixCreated?: (message: string) => void;
 };
-declare function SearchResults({ results, selectedIndex, isActive }: Props): import("react/jsx-runtime").JSX.Element | null;
+declare function SearchResults({ results, selectedIndex, isActive, onMixCreated, }: Props): import("react/jsx-runtime").JSX.Element | null;
 declare const _default: React.MemoExoticComponent<typeof SearchResults>;
 export default _default;

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

@@ -6,6 +6,7 @@ import { useTheme } from "../../hooks/useTheme.js";
 import { useNavigation } from "../../hooks/useNavigation.js";
 import { useKeyBinding } from "../../hooks/useKeyboard.js";
 import { usePlayer } from "../../hooks/usePlayer.js";
+import { usePlaylist } from "../../hooks/usePlaylist.js";
 import { KEYBINDINGS } from "../../utils/constants.js";
 import { truncate } from "../../utils/format.js";
 import { useCallback, useRef, useEffect } from 'react';
@@ -14,12 +15,15 @@ import { useTerminalSize } from "../../hooks/useTerminalSize.js";
 import { getMusicService } from "../../services/youtube-music/api.js";
 // Generate unique component instance ID
 let instanceCounter = 0;
-function SearchResults({ results, selectedIndex, isActive = true }) {
+function SearchResults({ results, selectedIndex, isActive = true, onMixCreated, }) {
     const { theme } = useTheme();
     const { dispatch } = useNavigation();
     const { play, dispatch: playerDispatch } = usePlayer();
     const { columns } = useTerminalSize();
     const musicService = getMusicService();
+    const { createPlaylist } = usePlaylist();
+    const mixCreatedRef = useRef(onMixCreated);
+    mixCreatedRef.current = onMixCreated;
     // Track component instance and last action time for debouncing
     const instanceIdRef = useRef(++instanceCounter);
     const lastSelectTime = useRef(0);
@@ -123,9 +127,100 @@ function SearchResults({ results, selectedIndex, isActive = true }) {
         logger.debug('SearchResults', 'SELECT key pressed', { isActive, instanceId });
         playSelected();
     }, [isActive, playSelected]);
+    const createMixPlaylist = useCallback(async () => {
+        if (!isActive)
+            return;
+        const selected = results[selectedIndex];
+        if (!selected) {
+            logger.warn('SearchResults', 'No result selected for mix');
+            return;
+        }
+        let playlistName = 'Dynamic mix';
+        const collectedTracks = [];
+        if (selected.type === 'song') {
+            const selectedTrack = selected.data;
+            const title = selectedTrack.title || 'selected track';
+            playlistName = `Mix for ${title}`;
+            collectedTracks.push(selectedTrack);
+            try {
+                const suggestions = await musicService.getSuggestions(selectedTrack.videoId);
+                collectedTracks.push(...suggestions);
+            }
+            catch (error) {
+                logger.error('SearchResults', 'Failed to fetch song suggestions', {
+                    error,
+                });
+            }
+        }
+        else if (selected.type === 'artist') {
+            const artistName = 'name' in selected.data ? selected.data.name : '';
+            if (!artistName) {
+                logger.warn('SearchResults', 'Artist name missing for mix');
+                mixCreatedRef.current?.('Artist information is missing, cannot create mix.');
+                return;
+            }
+            playlistName = `${artistName} mix`;
+            try {
+                const response = await musicService.search(artistName, {
+                    type: 'songs',
+                    limit: 25,
+                });
+                const artistTracks = response.results
+                    .filter(result => result.type === 'song')
+                    .map(result => result.data);
+                collectedTracks.push(...artistTracks);
+            }
+            catch (error) {
+                logger.error('SearchResults', 'Failed to fetch artist songs for mix', {
+                    error,
+                });
+            }
+        }
+        else {
+            logger.warn('SearchResults', 'Mix creation unsupported result type', {
+                type: selected.type,
+            });
+            mixCreatedRef.current?.('Mix creation is only supported for songs and artists.');
+            return;
+        }
+        const uniqueTracks = [];
+        const seenVideoIds = new Set();
+        for (const track of collectedTracks) {
+            if (!track?.videoId || seenVideoIds.has(track.videoId))
+                continue;
+            seenVideoIds.add(track.videoId);
+            uniqueTracks.push(track);
+        }
+        if (uniqueTracks.length === 0) {
+            mixCreatedRef.current?.('No similar tracks were found to create a mix.');
+            return;
+        }
+        const playlist = createPlaylist(playlistName, uniqueTracks);
+        logger.info('SearchResults', 'Mix playlist created', {
+            name: playlist.name,
+            trackCount: uniqueTracks.length,
+        });
+        // Queue the mix tracks and start playing the first one
+        playerDispatch({ category: 'SET_QUEUE', queue: uniqueTracks });
+        const firstTrack = uniqueTracks[0];
+        if (firstTrack) {
+            playerDispatch({ category: 'PLAY', track: firstTrack });
+        }
+        mixCreatedRef.current?.(`Created mix "${playlist.name}" with ${uniqueTracks.length} tracks — playing now.`);
+    }, [
+        createPlaylist,
+        isActive,
+        musicService,
+        playerDispatch,
+        results,
+        selectedIndex,
+    ]);
     useKeyBinding(KEYBINDINGS.UP, navigateUp);
     useKeyBinding(KEYBINDINGS.DOWN, navigateDown);
     useKeyBinding(KEYBINDINGS.SELECT, handleSelect);
+    useKeyBinding(KEYBINDINGS.CREATE_MIX, () => {
+        void createMixPlaylist();
+    });
     // Note: Removed redundant useEffect that was syncing selectedIndex to dispatch
     // This was causing unnecessary re-renders. The selectedIndex is already managed
     // by the parent component (SearchLayout) and passed down as a prop.

package/dist/source/hooks/usePlaylist.d.ts

@@ -2,7 +2,7 @@ import type { Playlist, Track } from '../types/youtube-music.types.ts';
 export type AddTrackResult = 'added' | 'duplicate';
 export declare function usePlaylist(): {
     playlists: Playlist[];
-    createPlaylist: (name: string) => void;
+    createPlaylist: (name: string, tracks?: Track[]) => Playlist;
     deletePlaylist: (playlistId: string) => void;
     renamePlaylist: (playlistId: string, newName: string) => void;
     addTrackToPlaylist: (playlistId: string, track: Track, force?: boolean) => AddTrackResult;

package/dist/source/hooks/usePlaylist.js

@@ -7,15 +7,16 @@ export function usePlaylist() {
     useEffect(() => {
         setPlaylists(configService.get('playlists'));
     }, []);
-    const createPlaylist = useCallback((name) => {
+    const createPlaylist = useCallback((name, tracks = []) => {
         const newPlaylist = {
             playlistId: Date.now().toString(),
             name,
-            tracks: [],
+            tracks: tracks.map(track => ({ ...track })),
         };
         const updatedPlaylists = [...playlists, newPlaylist];
         setPlaylists(updatedPlaylists);
         configService.set('playlists', updatedPlaylists);
+        return newPlaylist;
     }, [playlists, configService]);
     const deletePlaylist = useCallback((playlistId) => {
         const updatedPlaylists = playlists.filter(p => p.playlistId !== playlistId);

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

@@ -218,37 +218,39 @@ class MusicService {
     async getSuggestions(trackId) {
         try {
             const yt = await getClient();
-            let video = null;
-            try {
-                video = (await yt.getInfo(trackId));
-            }
-            catch (error) {
-                logger.warn('MusicService', 'getSuggestions getInfo failed', {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                return [];
-            }
-            const suggestions = video?.related?.contents ?? [];
+            // Use music.getUpNext with automix — avoids the yt.getInfo() ParsingError
+            // caused by YouTube "Remove ads" menu items that youtubei.js can't parse.
+            const panel = await yt.music.getUpNext(trackId, true);
             const tracks = [];
-            for (const item of suggestions) {
-                const videoId = item?.id || '';
-                if (!videoId)
+            for (const item of panel.contents) {
+                const video = item;
+                const videoId = video.video_id;
+                if (!videoId || videoId === trackId)
                     continue;
-                const title = typeof item.title === 'string' ? item.title : item.title?.text;
+                const title = typeof video.title === 'string'
+                    ? video.title
+                    : (video.title?.text ?? '');
                 if (!title)
                     continue;
                 tracks.push({
                     videoId,
                     title,
-                    artists: [],
+                    artists: (video.artists ?? []).map(a => ({
+                        artistId: a.channel_id ?? '',
+                        name: a.name ?? 'Unknown',
+                    })),
+                    duration: video.duration?.seconds ?? 0,
                 });
             }
-            return tracks.slice(0, 10);
+            logger.debug('MusicService', 'getSuggestions success', {
+                trackId,
+                count: tracks.length,
+            });
+            return tracks.slice(0, 15);
         }
         catch (error) {
-            logger.error('MusicService', 'getSuggestions failed', {
-                error: error instanceof Error ? error.message : String(error),
-            });
+            const message = error instanceof Error ? error.message : String(error);
+            logger.warn('MusicService', 'getSuggestions failed', { error: message });
             return [];
         }
     }

package/dist/source/utils/constants.d.ts

@@ -59,6 +59,7 @@ export declare const KEYBINDINGS: {
     readonly ADD_TO_PLAYLIST: readonly ["a"];
     readonly REMOVE_FROM_PLAYLIST: readonly ["d"];
     readonly CREATE_PLAYLIST: readonly ["c"];
+    readonly CREATE_MIX: readonly ["m"];
     readonly DELETE_PLAYLIST: readonly ["D"];
 };
 export declare const DEFAULT_VOLUME = 70;

package/dist/source/utils/constants.js

@@ -71,6 +71,7 @@ export const KEYBINDINGS = {
     ADD_TO_PLAYLIST: ['a'],
     REMOVE_FROM_PLAYLIST: ['d'],
     CREATE_PLAYLIST: ['c'],
+    CREATE_MIX: ['m'],
     DELETE_PLAYLIST: ['D'],
 };
 // Default volume

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "@involvex/youtube-music-cli",
-	"version": "0.0.8",
+	"version": "0.0.9",
 	"description": "- A Commandline music player for youtube-music",
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/involvex/youtube-music-cli"
+		"url": "git+https://github.com/involvex/youtube-music-cli.git"
 	},
 	"funding": "https://github.com/sponsors/involvex",
 	"license": "MIT",