wavesconv 1.4.9 → 1.6.0

package/cli.js

@@ -4,46 +4,11 @@
 const path = require('path');
 const fs = require('fs');
 const engine = require('./lib/engine');
+const ui = require('./lib/cli-ui');
+const { runInteractive } = require('./lib/cli-interactive');
 
 const VERSION = require('./package.json').version;
 
-const HELP = `
-WavesConverter CLI v${VERSION}
-
-Użycie:
-  wavesconv download <url> [opcje]     Pobierz wideo/audio z YouTube
-  wavesconv info <url>                 Pokaż metadane (JSON)
-  wavesconv convert <plik> [opcje]   Konwertuj plik lokalny
-  wavesconv tools install              Zainstaluj yt-dlp (do folderu użytkownika)
-  wavesconv tools status               Sprawdź yt-dlp i ffmpeg
-  wavesconv --help                     Ta pomoc
-  wavesconv --version                  Wersja
-
-Opcje download:
-  -o, --output <dir>       Folder docelowy (domyślnie: Downloads)
-  -f, --format <fmt>       mp4, mkv, webm, mp3, wav, flac… (domyślnie: mp4)
-  -q, --quality <q>        best, 1080p, 720p, 480p, 360p
-  -a, --audio              Tylko audio
-  --bitrate <rate>         np. 320k
-  --filename <szablon>     np. "%(title)s" lub "%(uploader)s - %(title)s"
-
-Opcje convert:
-  -o, --output <ścieżka>   Plik lub folder wyjściowy
-  -f, --format <fmt>       mp4, mp3, wav, gif…
-  -q, --quality <q>        Rozdzielczość wideo (1080p, 720p…)
-  --bitrate <rate>         Bitrate audio
-
-Przykłady:
-  wavesconv download "https://youtu.be/xxx" -a -f mp3
-  wavesconv download "https://youtube.com/watch?v=xxx" -q 1080p -o ~/Videos
-  wavesconv convert film.mp4 -f mp3 -o ~/Music/out.mp3
-  wavesconv info "https://youtu.be/xxx"
-
-Deep link (aplikacja graficzna):
-  wavesconverter://download?url=<encoded_url>
-  wavesconverter://queue?url=<encoded_url>&start=1
-`;
-
 function parseArgs(argv) {
   const args = [...argv];
   const positional = [];
@@ -59,7 +24,7 @@ function parseArgs(argv) {
     if (a.startsWith('--')) {
       const key = a.slice(2);
       args.shift();
-      if (['help', 'version', 'audio'].includes(key)) {
+      if (['help', 'version', 'audio', 'plain', 'json'].includes(key)) {
         flags[key] = true;
       } else if (args.length) {
         flags[key] = args.shift();
@@ -71,11 +36,8 @@ function parseArgs(argv) {
       args.shift();
       const map = { o: 'output', f: 'format', q: 'quality', a: 'audio' };
       const flagKey = map[key] || key;
-      if (key === 'a') {
-        flags.audio = true;
-      } else if (args.length) {
-        flags[flagKey] = args.shift();
-      }
+      if (key === 'a') flags.audio = true;
+      else if (args.length) flags[flagKey] = args.shift();
     } else {
       positional.push(args.shift());
     }
@@ -83,38 +45,75 @@ function parseArgs(argv) {
   return { positional, flags };
 }
 
-function log(msg) {
-  process.stderr.write(msg + '\n');
+async function cmdToolsInstall(color) {
+  const spin = new ui.Spinner('Instalacja yt-dlp', color);
+  spin.start();
+  try {
+    await engine.ensureYtDlp(msg => spin.draw(msg));
+    spin.succeed('yt-dlp zainstalowany');
+  } catch (e) {
+    spin.fail(e.message);
+    throw e;
+  }
+  ui.kv(color, 'yt-dlp', engine.findYtDlp() || 'błąd', !!engine.findYtDlp());
+  ui.kv(color, 'ffmpeg', engine.findFfmpeg() || 'brak (zainstaluj systemowo)', !!engine.findFfmpeg());
 }
 
-function formatBytes(n) {
-  if (n < 1024) return n + ' B';
-  if (n < 1024 * 1024) return (n / 1024).toFixed(1) + ' KB';
-  return (n / (1024 * 1024)).toFixed(2) + ' MB';
+function cmdToolsStatus(color) {
+  ui.printBanner(VERSION, color);
+  ui.kv(color, 'yt-dlp', engine.findYtDlp() || 'BRAK', !!engine.findYtDlp());
+  ui.kv(color, 'ffmpeg', engine.findFfmpeg() || 'BRAK', !!engine.findFfmpeg());
+  ui.kv(color, 'userData', engine.getUserDataDir());
+  console.log('');
 }
 
-async function cmdToolsInstall() {
-  await engine.ensureYtDlp(msg => log(msg));
-  log('yt-dlp: ' + (engine.findYtDlp() || 'błąd'));
-  log('ffmpeg: ' + (engine.findFfmpeg() || 'brak — zainstaluj systemowo lub z poziomu aplikacji'));
-}
+async function cmdInfo(url, flags, color) {
+  const spin = new ui.Spinner('Pobieranie metadanych', color);
+  spin.start();
+  let items;
+  try {
+    items = await engine.fetchInfo(url);
+    spin.succeed(`${items.length} element(ów)`);
+  } catch (e) {
+    spin.fail(e.message);
+    throw e;
+  }
 
-function cmdToolsStatus() {
-  log('yt-dlp: ' + (engine.findYtDlp() || 'BRAK'));
-  log('ffmpeg: ' + (engine.findFfmpeg() || 'BRAK'));
-  log('userData: ' + engine.getUserDataDir());
-}
+  if (flags.json || !color) {
+    console.log(JSON.stringify(items, null, 2));
+    return;
+  }
 
-async function cmdInfo(url) {
-  const items = await engine.fetchInfo(url);
-  console.log(JSON.stringify(items, null, 2));
+  if (items.length === 1) {
+    ui.printVideoCard(color, items[0]);
+    return;
+  }
+
+  ui.info(color, `Playlista: ${items.length} pozycji`);
+  items.slice(0, 15).forEach((item, i) => {
+    const title = (item.title || item.id || '?').slice(0, 50);
+    console.log(ui.c(color, ui.palette.cyan, `  ${String(i + 1).padStart(2)}. `) + title);
+  });
+  if (items.length > 15) {
+    console.log(ui.c(color, ui.palette.dim, `  … i ${items.length - 15} więcej`));
+  }
+  console.log('');
 }
 
-async function cmdDownload(url, flags) {
+async function cmdDownload(url, flags, color) {
   if (!engine.isYouTubeUrl(url)) {
     throw new Error('Nieprawidłowy URL YouTube: ' + url);
   }
-  await engine.ensureYtDlp(msg => log(msg));
+
+  const setupSpin = new ui.Spinner('Przygotowanie yt-dlp', color);
+  setupSpin.start();
+  try {
+    await engine.ensureYtDlp(msg => setupSpin.draw(msg));
+    setupSpin.succeed('Silnik gotowy');
+  } catch (e) {
+    setupSpin.fail(e.message);
+    throw e;
+  }
 
   const outputDir = path.resolve(flags.output || engine.getDefaultDownloadDir());
   if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
@@ -123,10 +122,15 @@ async function cmdDownload(url, flags) {
   const format = flags.format || (audioOnly ? 'mp3' : 'mp4');
 
   let title = 'download';
+  const metaSpin = new ui.Spinner('Wczytywanie metadanych', color);
+  metaSpin.start();
   try {
     const items = await engine.fetchInfo(url);
     if (items[0]) title = items[0].title || items[0].id || title;
-  } catch (_) {}
+    metaSpin.succeed(title.slice(0, 52) + (title.length > 52 ? '…' : ''));
+  } catch (_) {
+    metaSpin.succeed('Metadane pominięte');
+  }
 
   const job = {
     id: 'cli-' + Date.now(),
@@ -140,35 +144,35 @@ async function cmdDownload(url, flags) {
     filename: flags.filename || '%(title)s',
   };
 
-  log(`Pobieranie: ${title}`);
-  log(`Folder: ${outputDir}`);
-  log(`Format: ${format}${audioOnly ? ' (audio)' : ''} | Jakość: ${job.quality}`);
+  ui.info(color, `Folder: ${outputDir}`);
+  ui.info(color, `Format: ${format}${audioOnly ? ' (audio)' : ''} · Jakość: ${job.quality}`);
+  console.log('');
+
+  const bar = new ui.ProgressBar('Pobieranie', color);
+  bar.start();
 
-  let lastPct = -1;
   const result = await engine.runDownload(job, {
     onProgress: (pct, line) => {
-      const rounded = Math.floor(pct);
-      if (rounded !== lastPct && rounded % 5 === 0) {
-        lastPct = rounded;
-        process.stdout.write(`\r[${rounded}%] ${line.slice(0, 60).padEnd(60)}`);
-      }
+      const detail = line.replace(/\[download\]\s*/i, '').trim();
+      bar.update(pct, detail);
     },
     onLog: line => {
-      if (line.includes('ERROR') || line.includes('error')) log(line);
+      if (/\bERROR\b/i.test(line)) ui.warn(color, line.slice(0, 100));
     },
   });
 
-  process.stdout.write('\n');
+  bar.succeed(`Zapisano · ${ui.formatBytes(result.size || 0)}`);
   if (result.path) {
-    log(`Gotowe: ${result.path} (${formatBytes(result.size)})`);
+    ui.success(color, result.path);
   } else {
-    log('Pobrano (ścieżka nieznana — sprawdź folder docelowy)');
+    ui.warn(color, 'Sprawdź folder docelowy (ścieżka nie wykryta automatycznie)');
   }
+  console.log('');
 }
 
-async function cmdConvert(inputPath, flags) {
+async function cmdConvert(inputPath, flags, color) {
   const ffmpeg = engine.findFfmpeg();
-  if (!ffmpeg) throw new Error('ffmpeg nie znaleziony');
+  if (!ffmpeg) throw new Error('ffmpeg nie znaleziony — zainstaluj ffmpeg lub użyj aplikacji desktop');
 
   const resolvedIn = path.resolve(inputPath);
   if (!fs.existsSync(resolvedIn)) throw new Error('Plik nie istnieje: ' + resolvedIn);
@@ -195,30 +199,56 @@ async function cmdConvert(inputPath, flags) {
     gifDuration: flags['gif-duration'] || 5,
   };
 
-  log(`Konwersja → ${outputPath}`);
+  ui.info(color, `Wejście: ${path.basename(resolvedIn)}`);
+  ui.info(color, `Wyjście: ${outputPath}`);
+
+  const spin = new ui.Spinner('Konwersja ffmpeg', color);
+  spin.start();
+
   await engine.runConvert(job, {
-    onProgress: t => process.stdout.write(`\rCzas: ${t}    `),
+    onProgress: t => spin.draw(t),
   });
-  process.stdout.write('\n');
-  log('Gotowe: ' + outputPath);
+
+  spin.succeed('Konwersja zakończona');
+  ui.success(color, outputPath);
+  console.log('');
 }
 
 async function run(argv) {
   const { positional, flags } = parseArgs(argv);
+  const color = ui.useColor() && !flags.plain;
 
   if (flags.help || positional[0] === 'help') {
-    console.log(HELP);
+    ui.printHelp(VERSION, color);
     return 0;
   }
   if (flags.version) {
-    console.log(VERSION);
+    if (color) ui.printBanner(VERSION, true);
+    else console.log(VERSION);
     return 0;
   }
 
   const cmd = positional[0];
-  if (!cmd) {
-    console.log(HELP);
-    return 1;
+
+  // wavesconv — tryb interaktywny (wklej linki w konsoli)
+  if (!cmd || cmd === 'interactive' || cmd === 'i') {
+    if (!process.stdin.isTTY) {
+      ui.error(color, 'Tryb interaktywny wymaga terminala. Użyj: wavesconv download <url>');
+      return 1;
+    }
+    return runInteractive(
+      {
+        download: cmdDownload,
+        info: cmdInfo,
+        toolsInstall: cmdToolsInstall,
+      },
+      VERSION,
+      color
+    );
+  }
+
+  if (color && cmd !== 'tools') {
+    ui.printBanner(VERSION, true);
   }
 
   try {
@@ -226,25 +256,25 @@ async function run(argv) {
       case 'download': {
         const url = positional[1];
         if (!url) throw new Error('Podaj URL: wavesconv download <url>');
-        await cmdDownload(url, flags);
+        await cmdDownload(url, flags, color);
         return 0;
       }
       case 'info': {
         const url = positional[1];
         if (!url) throw new Error('Podaj URL: wavesconv info <url>');
-        await cmdInfo(url);
+        await cmdInfo(url, flags, color);
         return 0;
       }
       case 'convert': {
         const file = positional[1];
         if (!file) throw new Error('Podaj plik: wavesconv convert <plik>');
-        await cmdConvert(file, flags);
+        await cmdConvert(file, flags, color);
         return 0;
       }
       case 'tools': {
         const sub = positional[1];
-        if (sub === 'install') await cmdToolsInstall();
-        else if (sub === 'status') cmdToolsStatus();
+        if (sub === 'install') await cmdToolsInstall(color);
+        else if (sub === 'status') cmdToolsStatus(color);
         else throw new Error('Użyj: wavesconv tools install|status');
         return 0;
       }
@@ -252,7 +282,7 @@ async function run(argv) {
         throw new Error('Nieznane polecenie: ' + cmd);
     }
   } catch (e) {
-    log('Błąd: ' + (e.message || e));
+    ui.error(color, e.message || String(e));
     return 1;
   }
 }
@@ -268,4 +298,4 @@ if (require.main === module) {
   run(process.argv.slice(2)).then(code => process.exit(code));
 }
 
-module.exports = { run, shouldRunAsCli, HELP };
+module.exports = { run, shouldRunAsCli };

package/lib/cli-interactive.js

@@ -0,0 +1,288 @@
+'use strict';
+
+const readline = require('readline');
+const path = require('path');
+const fs = require('fs');
+const engine = require('./engine');
+const ui = require('./cli-ui');
+
+function defaultSession() {
+  return {
+    output: engine.getDefaultDownloadDir(),
+    format: 'mp4',
+    audioOnly: false,
+    quality: 'best',
+    bitrate: '',
+    filename: '%(title)s',
+  };
+}
+
+function sessionToFlags(session) {
+  return {
+    output: session.output,
+    format: session.format,
+    audio: session.audioOnly,
+    quality: session.quality,
+    bitrate: session.bitrate,
+    filename: session.filename,
+  };
+}
+
+function extractYouTubeUrls(text) {
+  const found = new Set();
+  const re = /https?:\/\/(?:www\.)?(?:youtube\.com\/[^\s]+|youtu\.be\/[^\s]+)/gi;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    found.add(m[0].replace(/[)\]},.;]+$/, ''));
+  }
+  const parts = text.trim().split(/\s+/).filter(Boolean);
+  for (const p of parts) {
+    if (engine.isYouTubeUrl(p)) found.add(p.replace(/[)\]},.;]+$/, ''));
+  }
+  return [...found];
+}
+
+function printSession(color, session) {
+  const mode = session.audioOnly ? 'audio' : 'wideo';
+  const fmt = session.format;
+  ui.info(
+    color,
+    `Tryb: ${mode} · ${fmt} · ${session.quality} · folder: ${session.output}`
+  );
+}
+
+function printInteractiveHelp(color) {
+  console.log('');
+  ui.info(color, 'Wklej link YouTube i naciśnij Enter — pobieranie startuje automatycznie.');
+  console.log(ui.c(color, ui.palette.dim, '  Komendy:'));
+  const cmds = [
+    ['/help', 'Ta pomoc'],
+    ['/info <url>', 'Podgląd bez pobierania'],
+    ['/audio', 'Tryb audio (mp3 domyślnie)'],
+    ['/video', 'Tryb wideo (mp4 domyślnie)'],
+    ['/fmt mp3', 'Format: mp4, mp3, webm, mkv…'],
+    ['/q 1080p', 'Jakość: best, 1080p, 720p…'],
+    ['/folder', 'Zmień folder pobierania'],
+    ['/folder C:\\Videos', 'Ustaw folder od razu'],
+    ['/status', 'Narzędzia yt-dlp / ffmpeg'],
+    ['/install', 'Zainstaluj yt-dlp'],
+    ['/quit', 'Wyjście (lub Ctrl+C)'],
+  ];
+  for (const [cmd, desc] of cmds) {
+    console.log('  ' + ui.c(color, ui.palette.cyan, cmd.padEnd(22)) + ui.c(color, ui.palette.dim, desc));
+  }
+  console.log('');
+}
+
+async function runInteractive(handlers, version, color) {
+  const session = defaultSession();
+  let ytDlpReady = false;
+
+  ui.printBanner(version, color);
+  printSession(color, session);
+  printInteractiveHelp(color);
+
+  const promptText = color
+    ? ui.c(true, ui.palette.pink, '🔗 ') + ui.c(true, ui.palette.bold, 'Wklej link') + ui.c(true, ui.palette.dim, ' › ')
+    : 'link> ';
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+    historySize: 100,
+  });
+
+  const ensureTools = async () => {
+    if (ytDlpReady && engine.findYtDlp()) return;
+    const spin = new ui.Spinner('Przygotowanie yt-dlp', color);
+    spin.start();
+    try {
+      await engine.ensureYtDlp(msg => spin.draw(msg));
+      spin.succeed('Gotowe');
+      ytDlpReady = true;
+    } catch (e) {
+      spin.fail(e.message);
+      throw e;
+    }
+  };
+
+  const askLine = (question) => new Promise(resolve => {
+    rl.question(question, answer => resolve(answer.trim()));
+  });
+
+  const processSlashCommand = async (line) => {
+    const parts = line.slice(1).trim().split(/\s+/);
+    const cmd = (parts[0] || '').toLowerCase();
+    const arg = parts.slice(1).join(' ');
+
+    switch (cmd) {
+      case 'help':
+      case 'h':
+      case '?':
+        printInteractiveHelp(color);
+        return;
+      case 'quit':
+      case 'exit':
+      case 'q':
+        ui.info(color, 'Do zobaczenia! 🌊');
+        rl.close();
+        return 'exit';
+      case 'audio':
+      case 'a':
+        session.audioOnly = true;
+        if (!['mp3', 'wav', 'flac', 'aac', 'm4a', 'ogg'].includes(session.format)) {
+          session.format = 'mp3';
+        }
+        ui.success(color, `Tryb audio · format: ${session.format}`);
+        printSession(color, session);
+        return;
+      case 'video':
+      case 'v':
+        session.audioOnly = false;
+        if (['mp3', 'wav', 'flac', 'aac', 'm4a', 'ogg'].includes(session.format)) {
+          session.format = 'mp4';
+        }
+        ui.success(color, `Tryb wideo · format: ${session.format}`);
+        printSession(color, session);
+        return;
+      case 'fmt':
+      case 'format':
+      case 'f':
+        if (!arg) {
+          ui.warn(color, 'Użyj: /fmt mp3  lub  /fmt mp4');
+          return;
+        }
+        session.format = arg.toLowerCase();
+        if (['mp3', 'wav', 'flac', 'aac', 'm4a', 'ogg'].includes(session.format)) {
+          session.audioOnly = true;
+        }
+        ui.success(color, `Format: ${session.format}`);
+        printSession(color, session);
+        return;
+      case 'q':
+      case 'quality':
+        if (!arg) {
+          ui.warn(color, 'Użyj: /q 1080p  lub  /q best');
+          return;
+        }
+        session.quality = arg;
+        ui.success(color, `Jakość: ${session.quality}`);
+        printSession(color, session);
+        return;
+      case 'folder':
+      case 'o':
+      case 'output':
+        if (arg) {
+          const dir = path.resolve(arg);
+          if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+          session.output = dir;
+          ui.success(color, 'Folder: ' + dir);
+        } else {
+          const entered = await askLine(
+            color ? ui.c(true, ui.palette.cyan, 'Ścieżka folderu: ') : 'Folder: '
+          );
+          if (entered) {
+            const dir = path.resolve(entered);
+            if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+            session.output = dir;
+            ui.success(color, 'Folder: ' + dir);
+          }
+        }
+        printSession(color, session);
+        return;
+      case 'status':
+        ui.kv(color, 'yt-dlp', engine.findYtDlp() || 'BRAK', !!engine.findYtDlp());
+        ui.kv(color, 'ffmpeg', engine.findFfmpeg() || 'BRAK', !!engine.findFfmpeg());
+        return;
+      case 'install':
+        await handlers.toolsInstall(color);
+        ytDlpReady = true;
+        return;
+      case 'info':
+      case 'i': {
+        const url = arg || '';
+        if (!url || !engine.isYouTubeUrl(url)) {
+          ui.warn(color, 'Użyj: /info <url>');
+          return;
+        }
+        await handlers.info(url, {}, color);
+        return;
+      }
+      case 'clear':
+        console.clear();
+        ui.printBanner(version, color);
+        printSession(color, session);
+        return;
+      default:
+        ui.warn(color, `Nieznana komenda: /${cmd} — wpisz /help`);
+    }
+  };
+
+  rl.setPrompt(promptText);
+
+  return new Promise(resolve => {
+    rl.on('close', () => resolve(0));
+
+    const loop = () => {
+      rl.prompt();
+    };
+
+    rl.on('line', async line => {
+      const trimmed = line.trim();
+      rl.pause();
+
+      try {
+        if (!trimmed) {
+          rl.resume();
+          loop();
+          return;
+        }
+
+        if (trimmed.startsWith('/')) {
+          const result = await processSlashCommand(trimmed);
+          if (result === 'exit') {
+            resolve(0);
+            return;
+          }
+          rl.resume();
+          loop();
+          return;
+        }
+
+        const urls = extractYouTubeUrls(trimmed);
+        if (!urls.length) {
+          ui.warn(color, 'Nie wykryto linku YouTube. Wklej URL lub wpisz /help');
+          rl.resume();
+          loop();
+          return;
+        }
+
+        await ensureTools();
+
+        for (let i = 0; i < urls.length; i++) {
+          if (urls.length > 1) {
+            ui.info(color, `Pobieranie ${i + 1}/${urls.length}`);
+          }
+          await handlers.download(urls[i], sessionToFlags(session), color);
+        }
+      } catch (e) {
+        ui.error(color, e.message || String(e));
+      }
+
+      rl.resume();
+      loop();
+    });
+
+    rl.on('SIGINT', () => {
+      console.log('');
+      ui.info(color, 'Wyjście (Ctrl+C)');
+      rl.close();
+      resolve(0);
+    });
+
+    loop();
+  });
+}
+
+module.exports = { runInteractive, defaultSession };

package/lib/cli-ui.js

@@ -0,0 +1,289 @@
+'use strict';
+
+const tty = process.stdout.isTTY;
+
+const ESC = '\x1b[';
+const reset = `${ESC}0m`;
+
+const palette = {
+  purple: `${ESC}38;2;192;132;252m`,
+  pink: `${ESC}38;2;232;121;249m`,
+  violet: `${ESC}38;2;124;58;237m`,
+  cyan: `${ESC}38;2;34;211;238m`,
+  green: `${ESC}38;2;74;222;128m`,
+  yellow: `${ESC}38;2;250;204;21m`,
+  red: `${ESC}38;2;248;113;113m`,
+  dim: `${ESC}2m`,
+  bold: `${ESC}1m`,
+};
+
+function useColor() {
+  if (process.env.NO_COLOR !== undefined) return false;
+  if (process.env.WAVESCONV_PLAIN === '1') return false;
+  if (process.argv.includes('--plain')) return false;
+  return tty;
+}
+
+function c(enabled, code, text) {
+  if (!enabled) return String(text);
+  return `${code}${text}${reset}`;
+}
+
+function gradientLine(enabled, text) {
+  if (!enabled) return text;
+  const chars = [...text];
+  const stops = [
+    [192, 132, 252],
+    [216, 126, 251],
+    [232, 121, 249],
+    [196, 116, 248],
+    [168, 85, 247],
+  ];
+  return chars.map((ch, i) => {
+    const t = chars.length <= 1 ? 0 : i / (chars.length - 1);
+    const idx = Math.min(stops.length - 1, Math.floor(t * (stops.length - 1)));
+    const [r, g, b] = stops[idx];
+    return `${ESC}38;2;${r};${g};${b}m${ch}`;
+  }).join('') + reset;
+}
+
+function printBanner(version, enabled) {
+  const wave = '～～～～～～～～～～～～～～～～～～～～～～～～～～～～～';
+  const title = `  WavesConverter CLI  v${version}  `;
+  console.log('');
+  console.log(c(enabled, palette.dim, '  ' + gradientLine(enabled, wave)));
+  console.log(c(enabled, palette.bold, gradientLine(enabled, title)));
+  console.log(c(enabled, palette.dim, '  ' + gradientLine(enabled, wave)));
+  console.log(c(enabled, palette.dim, '  Download anything · Convert everything\n'));
+}
+
+function printHelp(version, enabled) {
+  printBanner(version, enabled);
+  const rows = [
+    ['Polecenia', ''],
+    ['  download <url>', 'Pobierz wideo/audio z YouTube'],
+    ['  info <url>', 'Metadane (kolorowy podgląd lub JSON)'],
+    ['  convert <plik>', 'Konwertuj plik lokalny'],
+    ['  tools install', 'Zainstaluj yt-dlp'],
+    ['  tools status', 'Status yt-dlp i ffmpeg'],
+    ['  (bez argumentów)', 'Tryb interaktywny — wklej linki w konsoli'],
+    ['', ''],
+    ['Opcje download', ''],
+    ['  -o, --output <dir>', 'Folder docelowy'],
+    ['  -f, --format <fmt>', 'mp4, mp3, webm…'],
+    ['  -q, --quality <q>', 'best, 1080p, 720p…'],
+    ['  -a, --audio', 'Tylko audio'],
+    ['  --plain', 'Bez kolorów i animacji'],
+    ['', ''],
+    ['Przykłady', ''],
+    ['  wavesconv download URL -a -f mp3', ''],
+    ['  wavesconv convert film.mp4 -f mp3', ''],
+  ];
+  for (const [cmd, desc] of rows) {
+    if (!cmd && !desc) { console.log(''); continue; }
+    if (desc === '' && cmd && !cmd.startsWith(' ')) {
+      console.log(c(enabled, palette.pink, `\n  ${cmd}`));
+      continue;
+    }
+    if (cmd.startsWith('  ') && !cmd.includes('<') && desc === '') {
+      console.log(c(enabled, palette.cyan, `    ${cmd.trim()}`));
+      continue;
+    }
+    console.log(
+      c(enabled, palette.cyan, cmd.padEnd(28)) +
+      c(enabled, palette.dim, desc)
+    );
+  }
+  console.log('');
+}
+
+class Spinner {
+  constructor(text, enabled) {
+    this.text = text;
+    this.enabled = enabled && tty;
+    this.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    this.colors = [palette.purple, palette.pink, palette.violet, palette.cyan];
+    this.i = 0;
+    this.timer = null;
+  }
+
+  start() {
+    if (!this.enabled) {
+      process.stderr.write(this.text + '…\n');
+      return;
+    }
+    this.timer = setInterval(() => this.draw(), 80);
+    this.draw();
+  }
+
+  draw(extra = '') {
+    if (!this.enabled) return;
+    const frame = this.frames[this.i % this.frames.length];
+    const color = this.colors[Math.floor(this.i / 2) % this.colors.length];
+    const line = `${color}${frame}${reset} ${palette.bold}${this.text}${reset}${extra ? palette.dim + ' · ' + extra + reset : ''}`;
+    process.stderr.write(`\r\x1b[2K${line}`);
+    this.i++;
+  }
+
+  succeed(msg) {
+    this.stop();
+    process.stderr.write(c(this.enabled, palette.green, `✔ ${msg || this.text}\n`));
+  }
+
+  fail(msg) {
+    this.stop();
+    process.stderr.write(c(this.enabled, palette.red, `✖ ${msg || this.text}\n`));
+  }
+
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    if (this.enabled) process.stderr.write('\r\x1b[2K');
+  }
+}
+
+class ProgressBar {
+  constructor(label, enabled, width = 32) {
+    this.label = label;
+    this.enabled = enabled && tty;
+    this.width = width;
+    this.pct = 0;
+    this.detail = '';
+    this.pulse = 0;
+    this.timer = null;
+  }
+
+  start() {
+    if (!this.enabled) return;
+    this.timer = setInterval(() => {
+      this.pulse = (this.pulse + 1) % 4;
+      this.render();
+    }, 120);
+    this.render();
+  }
+
+  update(pct, detail = '') {
+    this.pct = Math.max(0, Math.min(100, pct));
+    if (detail) this.detail = detail.slice(0, 42);
+    if (!this.enabled) {
+      const r = Math.floor(this.pct);
+      if (r % 10 === 0 && r !== this._lastPlain) {
+        this._lastPlain = r;
+        process.stderr.write(`  ${r}%\n`);
+      }
+      return;
+    }
+    this.render();
+  }
+
+  render() {
+    if (!this.enabled) return;
+    const filled = Math.round((this.pct / 100) * this.width);
+    const blocks = ['░', '▒', '▓', '█'];
+    let bar = '';
+    for (let i = 0; i < this.width; i++) {
+      if (i < filled) bar += c(true, palette.pink, '█');
+      else if (i === filled) bar += c(true, palette.purple, blocks[this.pulse]);
+      else bar += c(true, palette.dim, '░');
+    }
+    const pctStr = `${String(Math.floor(this.pct)).padStart(3)}%`;
+    const line = `${c(true, palette.bold, this.label)} ${bar} ${c(true, palette.cyan, pctStr)}${this.detail ? c(true, palette.dim, '  ' + this.detail) : ''}`;
+    process.stdout.write(`\r\x1b[2K${line}`);
+  }
+
+  succeed(msg) {
+    if (this.timer) clearInterval(this.timer);
+    this.pct = 100;
+    if (this.enabled) {
+      this.render();
+      process.stdout.write('\n');
+      process.stderr.write(c(true, palette.green, `✔ ${msg}\n`));
+    } else {
+      process.stderr.write(msg + '\n');
+    }
+  }
+
+  fail(msg) {
+    if (this.timer) clearInterval(this.timer);
+    if (this.enabled) process.stdout.write('\n');
+    process.stderr.write(c(this.enabled, palette.red, `✖ ${msg}\n`));
+  }
+}
+
+function info(enabled, msg) {
+  process.stderr.write(c(enabled, palette.cyan, '◆ ') + msg + '\n');
+}
+
+function success(enabled, msg) {
+  process.stderr.write(c(enabled, palette.green, '✔ ') + c(enabled, palette.bold, msg) + '\n');
+}
+
+function warn(enabled, msg) {
+  process.stderr.write(c(enabled, palette.yellow, '⚠ ') + msg + '\n');
+}
+
+function error(enabled, msg) {
+  process.stderr.write(c(enabled, palette.red, '✖ ') + c(enabled, palette.bold, msg) + '\n');
+}
+
+function kv(enabled, key, value, ok) {
+  const icon = ok === true ? c(enabled, palette.green, '●') : ok === false ? c(enabled, palette.red, '○') : c(enabled, palette.purple, '●');
+  process.stderr.write(`  ${icon} ${c(enabled, palette.dim, key + ':')} ${c(enabled, ok === false ? palette.red : palette.bold, value)}\n`);
+}
+
+function printVideoCard(enabled, item) {
+  const title = item.title || item.id || 'Bez tytułu';
+  const uploader = item.uploader || '—';
+  const dur = item.duration ? formatDuration(item.duration) : '—';
+  const views = item.view_count ? formatViews(item.view_count) : '—';
+  console.log('');
+  console.log(c(enabled, palette.bold, gradientLine(enabled, '  ' + title.slice(0, 56))));
+  kv(enabled, 'Kanał', uploader);
+  kv(enabled, 'Czas', dur);
+  kv(enabled, 'Wyświetlenia', views);
+  if (item.webpage_url || item.url) kv(enabled, 'URL', item.webpage_url || item.url);
+  console.log('');
+}
+
+function formatDuration(sec) {
+  const h = Math.floor(sec / 3600);
+  const m = Math.floor((sec % 3600) / 60);
+  const s = Math.floor(sec % 60);
+  if (h) return `${h}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
+  return `${m}:${String(s).padStart(2, '0')}`;
+}
+
+function formatViews(n) {
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + 'M';
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + 'K';
+  return String(n);
+}
+
+function formatBytes(n) {
+  if (n < 1024) return n + ' B';
+  if (n < 1024 * 1024) return (n / 1024).toFixed(1) + ' KB';
+  return (n / (1024 * 1024)).toFixed(2) + ' MB';
+}
+
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+module.exports = {
+  useColor,
+  palette,
+  c,
+  printBanner,
+  printHelp,
+  Spinner,
+  ProgressBar,
+  info,
+  success,
+  warn,
+  error,
+  kv,
+  printVideoCard,
+  formatBytes,
+  sleep,
+  gradientLine,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wavesconv",
-  "version": "1.4.9",
+  "version": "1.6.0",
   "description": "CLI: pobieranie YouTube (yt-dlp) i konwersja mediów (ffmpeg) — WavesConverter",
   "main": "cli.js",
   "bin": {