lushapp 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pseudoshell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,104 @@
+# LUSH (`lushapp`)
+
+> Hyper-aesthetic terminal radio & music player with 560+ live streams, real-time CAVA DSP visualizers, retro studio decks, and ambient soundscapes.
+
+```text
+    __   __  __   _____ __  __
+   / /  / / / /  / ___// / / /
+  / /  / / / /   \__ \/ /_/ /     [ 560+ LIVE STATIONS ]
+ / /__/ /_/ /   ___/ / __  /      [ 19 CAVA VISUALIZERS ]
+/_____/\____/  /____/_/ /_/       [ 37 RICED THEMES ]
+```
+
+---
+
+## ✨ Features
+
+- **560+ Live Stations**: Lo-Fi, Synthwave, Cyberpunk, Ambient, Classical, ASMR, and curated Artist Discographies.
+- **Real-Time CAVA DSP Visualizers**: 19 spectrum analyzers (up to 144Hz) and 36 audio-reactive shimmers.
+- **Retro Studio Decks**: Kinetic Technics SL-1200 vinyl turntable and Nakamichi cassette deck animations.
+- **Ambient Soundscapes**: Layer rain, vinyl crackle, campfire, or café sounds over any stream.
+- **Lossless FLAC Recording**: Capture audio directly to `~/Music` in 24-bit FLAC with <kbd>Shift+R</kbd>.
+- **Listening Diary**: 100% offline analytics with a 16-week GitHub-style heatmap and streak tracking.
+- **Fuzzy Search**: Instant, typo-tolerant search across all stations with <kbd>/</kbd>.
+- **37 Themes**: Highly customizable color palettes with live preview.
+
+---
+
+## 🚀 Quick Start
+
+### Run Instantly (No Install)
+```bash
+npx lushapp
+```
+
+### Install via pip / npm
+```bash
+pip install lushapp
+# or
+npm install -g lushapp
+
+# Start with either command:
+lush
+# or
+lushapp
+```
+
+### Clone & Run from Source
+```bash
+git clone https://github.com/pseudoshell/lush.git
+cd lush
+./bin/lush
+```
+
+---
+
+## 📦 Prerequisites
+
+LUSH requires **Python 3.9+** and **mpv**. Install **cava** for live visualizers.
+
+| System | Command |
+| :--- | :--- |
+| **Arch / Manjaro** | `sudo pacman -S mpv cava python` |
+| **Ubuntu / Debian** | `sudo apt install mpv cava python3` |
+| **Fedora** | `sudo dnf install mpv cava python3` |
+| **macOS (Homebrew)** | `brew install mpv cava python` |
+
+---
+
+## 🕹️ Keybindings
+
+| Key | Action |
+| :--- | :--- |
+| <kbd>Space</kbd> | Play / Pause active stream |
+| <kbd>/</kbd> | Live fuzzy search |
+| <kbd>1</kbd> – <kbd>5</kbd> | Jump to Music categories (Top Artists, Gen Z, Legends, New Age, All) |
+| <kbd>0</kbd> | Jump to All Web Radios |
+| <kbd>p</kbd> | Open Now Playing Studio deck |
+| <kbd>d</kbd> | Switch deck style (Turntable ↔ Cassette) |
+| <kbd>v</kbd> | Cycle CAVA visualizers |
+| <kbd>t</kbd> / <kbd>T</kbd> | Cycle / Select theme |
+| <kbd>e</kbd> / <kbd>E</kbd> | Toggle / Configure ambient sounds |
+| <kbd>Shift</kbd> + <kbd>R</kbd> | Toggle lossless FLAC recording |
+| <kbd>b</kbd> | Add / Remove favorite station |
+| <kbd>s</kbd> | Open Settings menu |
+| <kbd>?</kbd> | Help modal |
+| <kbd>q</kbd> | Quit |
+
+---
+
+## 🧪 Diagnostics & Testing
+
+Run the live streaming test suite:
+
+```bash
+lush --test
+# or
+python3 tests/run_tests.py
+```
+
+---
+
+## 📄 License
+
+MIT © 2026 pseudoshell

package/bin/lush

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+import sys
+import os
+from pathlib import Path
+
+# Ensure lush package paths are in sys.path
+for path_cand in [
+    Path(__file__).resolve().parent.parent / 'src',
+    Path(__file__).resolve().parent.parent / 'lib',
+    Path.home() / '.local' / 'lib',
+]:
+    if (path_cand / 'lush').exists():
+        p_str = str(path_cand)
+        if p_str not in sys.path:
+            sys.path.insert(0, p_str)
+
+import shutil
+import subprocess
+
+def ensure_audio_backend():
+    """Detects if an audio player backend is available; offers auto-install if missing."""
+    if shutil.which("mpv") or shutil.which("ffplay") or shutil.which("cvlc"):
+        return
+
+    # No backend detected
+    pkg_managers = [
+        ("pacman", "sudo pacman -S --noconfirm mpv cava"),
+        ("apt-get", "sudo apt-get update && sudo apt-get install -y mpv cava"),
+        ("dnf", "sudo dnf install -y mpv cava"),
+        ("brew", "brew install mpv cava"),
+        ("zypper", "sudo zypper install -y mpv cava"),
+        ("apk", "sudo apk add mpv cava"),
+        ("pkg", "pkg install -y mpv"),
+        ("winget", "winget install mpv.mpv")
+    ]
+
+    detected_cmd = None
+    for pm, cmd in pkg_managers:
+        if shutil.which(pm):
+            detected_cmd = cmd
+            break
+
+    if sys.stdin.isatty() and detected_cmd:
+        print("\033[1;95m┌────────────────────────────────────────────────────────────────────────┐\033[0m")
+        print("\033[1;95m│\033[0m  \033[1;96mLUSH Setup:\033[0m Audio player backend (\033[1;93mmpv\033[0m) not detected.                 \033[1;95m│\033[0m")
+        print(f"\033[1;95m│\033[0m  Auto-install via \033[1;92m{detected_cmd:<44}\033[0m \033[1;95m│\033[0m")
+        print("\033[1;95m└────────────────────────────────────────────────────────────────────────┘\033[0m")
+        try:
+            ans = input("Proceed with auto-install? [Y/n]: ").strip().lower()
+            if ans in ("", "y", "yes"):
+                print("\n\033[1;96mInstalling audio dependencies...\033[0m")
+                subprocess.run(detected_cmd, shell=True)
+                print("\033[1;92m✓ Installation complete! Launching LUSH...\033[0m\n")
+        except (KeyboardInterrupt, EOFError):
+            pass
+
+ensure_audio_backend()
+
+from lush.__main__ import main
+
+if __name__ == '__main__':
+    main()

package/bin/lush.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const binPath = path.join(__dirname, 'lush');
+
+function getPythonExecutable() {
+  const candidates = process.platform === 'win32'
+    ? ['python3', 'python', 'py']
+    : ['python3', 'python'];
+
+  for (const cmd of candidates) {
+    try {
+      const checkCmd = process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`;
+      execSync(checkCmd, { stdio: 'ignore' });
+      return cmd;
+    } catch {}
+  }
+  return 'python3';
+}
+
+const pythonCmd = getPythonExecutable();
+
+const child = spawn(pythonCmd, [binPath, ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  env: {
+    ...process.env,
+    PYTHONPATH: path.join(__dirname, '..', 'src')
+  }
+});
+
+child.on('error', (err) => {
+  if (err.code === 'ENOENT') {
+    console.error('\x1b[1;95m┌────────────────────────────────────────────────────────────────────────┐\x1b[0m');
+    console.error('\x1b[1;95m│\x1b[0m  \x1b[1;91m[ERROR]\x1b[0m Python 3 is required to run LUSH.                           \x1b[1;95m│\x1b[0m');
+    console.error('\x1b[1;95m│\x1b[0m  Install via: \x1b[1;96msudo apt install python3 mpv cava\x1b[0m (or \x1b[1;96mbrew install python mpv cava\x1b[0m) \x1b[1;95m│\x1b[0m');
+    console.error('\x1b[1;95m└────────────────────────────────────────────────────────────────────────┘\x1b[0m');
+  } else {
+    console.error('\x1b[31m[ERROR]\x1b[0m Failed to start LUSH:', err.message);
+  }
+  process.exit(1);
+});
+
+child.on('exit', (code, signal) => {
+  process.exit(code !== null ? code : (signal ? 1 : 0));
+});

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "lushapp",
+  "version": "2.0.0",
+  "description": "A hyper-aesthetic terminal radio player with 560+ live stations, real-time CAVA DSP audio visualizers, ambient soundscapes, and artist discographies.",
+  "main": "bin/lush.js",
+  "bin": {
+    "lush": "bin/lush.js",
+    "lushapp": "bin/lush.js"
+  },
+  "scripts": {
+    "start": "node bin/lush.js",
+    "dev": "node bin/lush.js",
+    "build": "python3 -m compileall -q src/lush && npm pack --dry-run",
+    "pack": "npm pack",
+    "diag": "node bin/lush.js --test",
+    "test": "python3 tests/run_tests.py",
+    "clean": "node -e \"const fs=require('fs');fs.readdirSync('.').filter(f=>f.endsWith('.tgz')).forEach(f=>fs.unlinkSync(f))\"",
+    "postinstall": "node scripts/postinstall.js",
+    "version": "node scripts/sync-version.js && git add pyproject.toml setup.py src/lush/__init__.py",
+    "prepack": "python3 tests/run_tests.py",
+    "prepublishOnly": "python3 tests/run_tests.py"
+  },
+  "keywords": [
+    "tui",
+    "radio",
+    "music",
+    "terminal",
+    "audio-player",
+    "visualizer",
+    "cava",
+    "cli",
+    "ambient",
+    "curses",
+    "python",
+    "lofi",
+    "synthwave"
+  ],
+  "author": "pseudoshell",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pseudoshell/lush.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pseudoshell/lush/issues"
+  },
+  "homepage": "https://github.com/pseudoshell/lush#readme",
+  "files": [
+    "bin/",
+    "scripts/",
+    "src/lush/*.py",
+    "src/lush/data/*",
+    "LICENSE",
+    "README.md",
+    "pyproject.toml",
+    "setup.py"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lushapp"
+version = "2.0.0"
+description = "A hyper-aesthetic terminal radio player with 560+ live stations, real-time CAVA DSP visualizers, and artist discographies."
+readme = "README.md"
+authors = [{ name = "pseudoshell" }]
+license = { text = "MIT" }
+requires-python = ">=3.8"
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console :: Curses",
+    "Intended Audience :: End Users/Desktop",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Multimedia :: Sound/Audio :: Players",
+]
+dependencies = [
+    "python-mpv>=0.5.2",
+    "pyperclip>=1.8.2",
+    "requests>=2.28.0",
+    "yt-dlp>=2024.1.0",
+    "windows-curses>=2.3.0; sys_platform == 'win32'",
+]
+
+[project.scripts]
+lush = "lush.__main__:main"
+lushapp = "lush.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/pseudoshell/lush"
+Repository = "https://github.com/pseudoshell/lush.git"
+Issues = "https://github.com/pseudoshell/lush/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+lush = ["data/*.json", "data/*.conf"]

package/scripts/postinstall.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+const { execSync } = require('child_process');
+
+function which(cmd) {
+  try {
+    const checkCmd = process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`;
+    execSync(checkCmd, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const missing = [];
+if (!which('python3') && !which('python')) missing.push('python3');
+if (!which('mpv')) missing.push('mpv');
+if (!which('cava')) missing.push('cava');
+if (!which('ffmpeg')) missing.push('ffmpeg');
+
+if (missing.length === 0) {
+  console.log('\x1b[1;92m✓ [LUSH]\x1b[0m All system dependencies (python3, mpv, cava, ffmpeg) are verified.');
+  process.exit(0);
+}
+
+console.log(`\x1b[1;95m┌────────────────────────────────────────────────────────────────────────┐\x1b[0m`);
+console.log(`\x1b[1;95m│\x1b[0m  \x1b[1;96mLUSH Setup:\x1b[0m Missing dependencies detected: \x1b[1;93m${missing.join(', ')}\x1b[0m           \x1b[1;95m│\x1b[0m`);
+console.log(`\x1b[1;95m│\x1b[0m  Attempting automated installation via system package manager...       \x1b[1;95m│\x1b[0m`);
+console.log(`\x1b[1;95m└────────────────────────────────────────────────────────────────────────┘\x1b[0m`);
+
+let installCmd = null;
+if (which('pacman')) {
+  installCmd = `sudo pacman -S --noconfirm --needed ${missing.join(' ')}`;
+} else if (which('apt-get')) {
+  installCmd = `sudo apt-get update -qq && sudo apt-get install -y ${missing.join(' ')}`;
+} else if (which('dnf')) {
+  installCmd = `sudo dnf install -y ${missing.join(' ')}`;
+} else if (which('brew')) {
+  installCmd = `brew install ${missing.join(' ')}`;
+} else if (which('zypper')) {
+  installCmd = `sudo zypper install -y ${missing.join(' ')}`;
+} else if (which('apk')) {
+  installCmd = `sudo apk add ${missing.join(' ')}`;
+} else if (which('winget')) {
+  installCmd = `winget install mpv.mpv`;
+}
+
+if (installCmd) {
+  try {
+    console.log(`\x1b[96m> Running: ${installCmd}\x1b[0m\n`);
+    execSync(installCmd, { stdio: 'inherit' });
+    console.log('\n\x1b[1;92m✓ [LUSH] Dependencies successfully installed! Ready to launch `lush`.\x1b[0m\n');
+  } catch (err) {
+    console.log(`\x1b[1;93m[NOTICE]\x1b[0m Automated installation required manual elevation.`);
+    console.log(`Run: \x1b[1;96m${installCmd}\x1b[0m to finalize setup.\n`);
+  }
+} else {
+  console.log(`\x1b[1;93m[NOTICE]\x1b[0m Please install missing tools (\x1b[1;96m${missing.join(', ')}\x1b[0m) with your package manager.\n`);
+}

package/scripts/sync-version.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+
+const rootDir = path.resolve(__dirname, '..');
+const pkg = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'));
+const newVer = pkg.version;
+
+console.log(`\x1b[96m[LUSH Version Sync]\x1b[0m Syncing version \x1b[92mv${newVer}\x1b[0m across all manifests...`);
+
+// 1. Update pyproject.toml
+const pyprojectPath = path.join(rootDir, 'pyproject.toml');
+if (fs.existsSync(pyprojectPath)) {
+  let content = fs.readFileSync(pyprojectPath, 'utf8');
+  content = content.replace(/^version\s*=\s*["'][^"']+["']/m, `version = "${newVer}"`);
+  fs.writeFileSync(pyprojectPath, content, 'utf8');
+  console.log(`  ✓ Updated pyproject.toml -> ${newVer}`);
+}
+
+// 2. Update setup.py
+const setupPath = path.join(rootDir, 'setup.py');
+if (fs.existsSync(setupPath)) {
+  let content = fs.readFileSync(setupPath, 'utf8');
+  content = content.replace(/version\s*=\s*["'][^"']+["']/m, `version="${newVer}"`);
+  fs.writeFileSync(setupPath, content, 'utf8');
+  console.log(`  ✓ Updated setup.py -> ${newVer}`);
+}
+
+// 3. Update src/lush/__init__.py
+const initPath = path.join(rootDir, 'src', 'lush', '__init__.py');
+if (fs.existsSync(initPath)) {
+  let content = fs.readFileSync(initPath, 'utf8');
+  content = content.replace(/__version__\s*=\s*["'][^"']+["']/m, `__version__ = "${newVer}"`);
+  fs.writeFileSync(initPath, content, 'utf8');
+  console.log(`  ✓ Updated src/lush/__init__.py -> ${newVer}`);
+}
+
+console.log('\x1b[1;92m✓ All package versions synchronized successfully!\x1b[0m\n');

package/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="lushapp",
+    version="2.0.0",
+    package_dir={"": "src"},
+    packages=find_packages(where="src"),
+    include_package_data=True,
+    package_data={"lush": ["data/*.json", "data/*.conf"]},
+    entry_points={
+        "console_scripts": [
+            "lush = lush.__main__:main",
+            "lushapp = lush.__main__:main",
+        ],
+    },
+    install_requires=[
+        "python-mpv>=0.5.2",
+        "pyperclip>=1.8.2",
+        "requests>=2.28.0",
+        "yt-dlp>=2024.1.0",
+        "windows-curses>=2.3.0; sys_platform == 'win32'",
+    ],
+)

package/src/lush/__init__.py

@@ -0,0 +1,30 @@
+import os
+os.environ["ESCDELAY"] = "25"
+
+__version__ = "2.0.0"
+
+def run_app():
+    try:
+        import curses
+    except ImportError:
+        try:
+            import windows_curses as curses
+        except ImportError:
+            print("\033[1;91m[ERROR]\033[0m Python curses library is required to run LUSH.")
+            if os.name == "nt":
+                print("On Windows, install it via: \033[1;96mpip install windows-curses\033[0m")
+            return
+
+    import threading
+    from .state import PlayerState, metadata_loop
+    from .ui import curses_main
+
+    state = PlayerState()
+    t_meta = threading.Thread(target=metadata_loop, args=(state,), daemon=True)
+    t_meta.start()
+
+    curses.wrapper(curses_main, state)
+
+if __name__ == "__main__":
+    run_app()
+

package/src/lush/__main__.py

@@ -0,0 +1,42 @@
+# LUSH - CLI Main Entrypoint
+import sys
+import argparse
+from . import __version__, run_app
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="lush",
+        description="LUSH - A hyper-aesthetic terminal radio player with 560+ live stations and real-time CAVA DSP visualizers.",
+        epilog="Keybindings: [Space] Play/Pause | [/] Search | [p] Now Playing | [d] Decks | [1-5] Music | [0] Radio | [v] Visualizers | [t] Themes | [e] Ambient | [Shift+R] Record | [q] Quit"
+    )
+    parser.add_argument("-v", "--version", action="version", version=f"LUSH v{__version__} (Audiophile Edition)")
+    parser.add_argument("--test", action="store_true", help="Run internal self-test diagnostics")
+
+    args, unknown = parser.parse_known_args()
+
+    if args.test:
+        from pathlib import Path
+        test_cands = [
+            Path(__file__).resolve().parent.parent.parent / "tests" / "run_tests.py",
+            Path.home() / "lush" / "tests" / "run_tests.py",
+            Path.cwd() / "tests" / "run_tests.py"
+        ]
+        runner_path = next((p for p in test_cands if p.exists()), None)
+        if runner_path:
+            import subprocess
+            res = subprocess.run([sys.executable, str(runner_path)])
+            sys.exit(res.returncode)
+        else:
+            from .state import PlayerState
+            state = PlayerState()
+            stations = state.get_filtered_stations()
+            print(f"LUSH v{__version__} Self-Test:")
+            print(f"  [OK] Station Catalog: {len(stations)} live streams loaded.")
+            state.shutdown()
+            print("  [OK] All core subsystems verified successfully.")
+            sys.exit(0)
+
+    run_app()
+
+if __name__ == "__main__":
+    main()