wrkmon 1.0.1__py3-none-any.whl

wrkmon/ui/screens/search.py

@@ -0,0 +1,165 @@
+"""Search screen for wrkmon."""
+
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.containers import Vertical, ScrollableContainer
+from textual.widgets import Static, Input, ListView, ListItem, Label
+from textual.binding import Binding
+from textual import on
+
+from wrkmon.core.youtube import SearchResult
+
+
+class SearchResultItem(ListItem):
+    """A search result list item."""
+
+    def __init__(self, result: SearchResult, index: int, **kwargs):
+        super().__init__(**kwargs)
+        self.result = result
+        self.index = index
+
+    def compose(self) -> ComposeResult:
+        from wrkmon.utils.stealth import get_stealth
+        stealth = get_stealth()
+
+        process_name = stealth.get_fake_process_name(self.result.title)[:40]
+        fake_pid = stealth.get_fake_pid()
+        status = "READY"
+
+        # Format: index | process name | pid | status
+        text = f"{self.index:2}  {process_name:<42} {fake_pid:>6}  {status}"
+        yield Label(text)
+
+
+class SearchScreen(Screen):
+    """Main search screen."""
+
+    BINDINGS = [
+        Binding("escape", "clear_or_back", "Clear/Back", show=False),
+        Binding("/", "focus_search", "Search", show=False),
+        Binding("enter", "play_selected", "Play", show=False),
+        Binding("q", "add_to_queue", "Add to Queue", show=False),
+        Binding("a", "add_to_playlist", "Add to Playlist", show=False),
+    ]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.results: list[SearchResult] = []
+        self._searching = False
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="search-screen"):
+            # Search header
+            yield Static("> Search: ", id="search-label")
+            yield Input(placeholder="Enter search query...", id="search-input")
+
+            # Results header (looks like ps output)
+            yield Static(
+                " #   Process Name                                  PID     Status",
+                id="results-header",
+            )
+
+            # Results list
+            yield ListView(id="results-list")
+
+            # Status message
+            yield Static("", id="status-message")
+
+    def on_mount(self) -> None:
+        """Called when screen is mounted."""
+        self.query_one("#search-input", Input).focus()
+
+    @on(Input.Submitted, "#search-input")
+    async def handle_search(self, event: Input.Submitted) -> None:
+        """Handle search submission."""
+        query = event.value.strip()
+        if not query:
+            return
+
+        self._searching = True
+        self.update_status("Searching...")
+
+        try:
+            youtube = self.app.youtube
+            self.results = await youtube.search(query, max_results=15)
+            self.display_results()
+        except Exception as e:
+            self.update_status(f"Search failed: {e}")
+        finally:
+            self._searching = False
+
+    def display_results(self) -> None:
+        """Display search results."""
+        list_view = self.query_one("#results-list", ListView)
+        list_view.clear()
+
+        if not self.results:
+            self.update_status("No results found")
+            return
+
+        for i, result in enumerate(self.results, 1):
+            list_view.append(SearchResultItem(result, i))
+
+        self.update_status(f"Found {len(self.results)} processes")
+        list_view.focus()
+
+    def update_status(self, message: str) -> None:
+        """Update status message."""
+        self.query_one("#status-message", Static).update(message)
+
+    def action_focus_search(self) -> None:
+        """Focus the search input."""
+        self.query_one("#search-input", Input).focus()
+
+    def action_clear_or_back(self) -> None:
+        """Clear search or go back."""
+        search_input = self.query_one("#search-input", Input)
+        if search_input.value:
+            search_input.value = ""
+            search_input.focus()
+        else:
+            # Could go back to previous screen if we had one
+            pass
+
+    async def action_play_selected(self) -> None:
+        """Play the selected result."""
+        list_view = self.query_one("#results-list", ListView)
+        if list_view.highlighted_child is None:
+            return
+
+        item = list_view.highlighted_child
+        if isinstance(item, SearchResultItem):
+            await self.app.play_track(item.result)
+
+    async def action_add_to_queue(self) -> None:
+        """Add selected to queue."""
+        list_view = self.query_one("#results-list", ListView)
+        if list_view.highlighted_child is None:
+            return
+
+        item = list_view.highlighted_child
+        if isinstance(item, SearchResultItem):
+            self.app.add_to_queue(item.result)
+            self.update_status(f"Added to queue: {item.result.title[:30]}...")
+
+    def action_add_to_playlist(self) -> None:
+        """Add selected to a playlist."""
+        list_view = self.query_one("#results-list", ListView)
+        if list_view.highlighted_child is None:
+            return
+
+        item = list_view.highlighted_child
+        if isinstance(item, SearchResultItem):
+            # TODO: Show playlist selection modal
+            self.update_status("Playlist feature coming soon")
+
+    def get_selected_result(self) -> SearchResult | None:
+        """Get the currently selected search result."""
+        list_view = self.query_one("#results-list", ListView)
+        if list_view.highlighted_child is None:
+            return None
+
+        item = list_view.highlighted_child
+        if isinstance(item, SearchResultItem):
+            return item.result
+        return None

wrkmon/ui/theme.py

@@ -0,0 +1,326 @@
+"""Theme and CSS for wrkmon TUI."""
+
+# Main application CSS
+APP_CSS = """
+/* ============================================
+   WRKMON - Terminal Music Player Theme
+   Designed to look like a system monitor
+   ============================================ */
+
+/* Base screen styling */
+Screen {
+    background: #0a0a0a;
+}
+
+/* ----------------------------------------
+   HEADER BAR
+   ---------------------------------------- */
+HeaderBar {
+    dock: top;
+    height: 1;
+    background: #1a1a1a;
+    color: #00ff00;
+}
+
+#header-inner {
+    width: 100%;
+}
+
+#app-title {
+    width: auto;
+    color: #00ff00;
+    text-style: bold;
+    padding: 0 1;
+}
+
+#current-view {
+    width: 1fr;
+    color: #008800;
+    padding: 0 1;
+}
+
+#sys-stats {
+    width: auto;
+    color: #888888;
+    padding: 0 1;
+}
+
+/* ----------------------------------------
+   PLAYER BAR (Bottom)
+   ---------------------------------------- */
+PlayerBar {
+    dock: bottom;
+    height: 5;
+    background: #1a1a1a;
+    border-top: solid #333333;
+    padding: 0 1;
+}
+
+#player-bar-inner {
+    height: 100%;
+}
+
+#now-playing-row {
+    height: 1;
+}
+
+#now-label {
+    width: 4;
+    color: #888888;
+}
+
+#play-status {
+    width: 2;
+    color: #00ff00;
+}
+
+#track-title {
+    width: 1fr;
+    color: #ffffff;
+}
+
+#progress-row {
+    height: 1;
+    padding: 0 1;
+}
+
+#time-current, #time-total {
+    width: 8;
+    color: #888888;
+}
+
+#progress {
+    width: 1fr;
+    background: #333333;
+}
+
+#progress > .bar--bar {
+    color: #00ff00;
+}
+
+#volume-row {
+    height: 1;
+}
+
+#vol-label {
+    width: 4;
+    color: #888888;
+}
+
+#volume {
+    width: 20;
+    background: #333333;
+}
+
+#volume > .bar--bar {
+    color: #00ffff;
+}
+
+#vol-value {
+    width: 5;
+    color: #888888;
+}
+
+/* ----------------------------------------
+   CONTENT SWITCHER / MAIN AREA
+   ---------------------------------------- */
+#content-area {
+    height: 1fr;
+}
+
+ContentSwitcher {
+    height: 1fr;
+}
+
+/* ----------------------------------------
+   VIEW CONTAINERS
+   ---------------------------------------- */
+SearchView, QueueView, HistoryView, PlaylistsView {
+    height: 1fr;
+    padding: 0 1;
+}
+
+#view-title {
+    height: 1;
+    color: #00ff00;
+    text-style: bold;
+    background: #111111;
+    padding: 0 1;
+}
+
+/* Search container */
+#search-container {
+    height: auto;
+    padding: 1 0;
+}
+
+#search-input {
+    width: 100%;
+    background: #1a1a1a;
+    border: tall #333333;
+    color: #ffffff;
+}
+
+#search-input:focus {
+    border: tall #00ff00;
+}
+
+/* List headers (column titles) */
+#list-header {
+    height: 1;
+    color: #888888;
+    background: #111111;
+    text-style: bold;
+}
+
+/* Result/Queue/History lists */
+#results-list, #queue-list, #history-list, #playlist-list {
+    height: 1fr;
+    background: #0a0a0a;
+    scrollbar-background: #1a1a1a;
+    scrollbar-color: #333333;
+}
+
+ListView > ListItem {
+    height: 1;
+    padding: 0 1;
+    color: #cccccc;
+}
+
+ListView > ListItem:hover {
+    background: #1a1a1a;
+}
+
+ListView > ListItem.-highlight {
+    background: #222222;
+    color: #00ff00;
+}
+
+.result-text, .queue-text, .history-text {
+    width: 100%;
+}
+
+/* Status bar */
+#status-bar {
+    dock: bottom;
+    height: 1;
+    color: #888888;
+    background: #111111;
+    padding: 0 1;
+}
+
+/* ----------------------------------------
+   QUEUE VIEW SPECIFICS
+   ---------------------------------------- */
+#now-playing-section {
+    height: auto;
+    background: #111111;
+    padding: 1;
+    margin-bottom: 1;
+}
+
+#section-header {
+    color: #888888;
+    text-style: bold;
+}
+
+#current-track {
+    color: #00ff00;
+    padding: 0 1;
+}
+
+#playback-progress {
+    height: 1;
+    padding: 0 1;
+}
+
+#track-progress {
+    width: 1fr;
+    background: #333333;
+}
+
+#track-progress > .bar--bar {
+    color: #00ff00;
+}
+
+#pos-time, #dur-time {
+    width: 8;
+    color: #888888;
+}
+
+#mode-indicators {
+    height: 1;
+    padding: 0 1;
+}
+
+#shuffle-indicator, #repeat-indicator {
+    width: auto;
+    color: #00ffff;
+    padding: 0 1;
+}
+
+/* ----------------------------------------
+   PLAYLIST INPUT
+   ---------------------------------------- */
+#new-playlist-input {
+    width: 100%;
+    background: #1a1a1a;
+    border: tall #333333;
+    color: #ffffff;
+    margin: 1 0;
+}
+
+#new-playlist-input:focus {
+    border: tall #00ff00;
+}
+
+/* ----------------------------------------
+   FOOTER
+   ---------------------------------------- */
+Footer {
+    background: #111111;
+    color: #888888;
+}
+
+Footer > .footer--key {
+    color: #00ff00;
+    background: #1a1a1a;
+}
+
+Footer > .footer--description {
+    color: #888888;
+}
+
+/* ----------------------------------------
+   LABELS (General)
+   ---------------------------------------- */
+.label {
+    color: #888888;
+}
+
+"""
+
+# Alternative themes (can be switched via config)
+THEMES = {
+    "matrix": {
+        "primary": "#00ff00",
+        "secondary": "#008800",
+        "accent": "#00ffff",
+        "background": "#0a0a0a",
+        "surface": "#1a1a1a",
+    },
+    "hacker": {
+        "primary": "#00ffff",
+        "secondary": "#008888",
+        "accent": "#ff00ff",
+        "background": "#0a0a0a",
+        "surface": "#1a1a1a",
+    },
+    "minimal": {
+        "primary": "#ffffff",
+        "secondary": "#888888",
+        "accent": "#4444ff",
+        "background": "#000000",
+        "surface": "#111111",
+    },
+}

wrkmon/ui/views/__init__.py

@@ -0,0 +1,8 @@
+"""View containers for wrkmon TUI."""
+
+from wrkmon.ui.views.search import SearchView
+from wrkmon.ui.views.queue import QueueView
+from wrkmon.ui.views.history import HistoryView
+from wrkmon.ui.views.playlists import PlaylistsView
+
+__all__ = ["SearchView", "QueueView", "HistoryView", "PlaylistsView"]

wrkmon/ui/views/history.py

@@ -0,0 +1,138 @@
+"""History view container for wrkmon."""
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Static, ListView
+from textual.binding import Binding
+from textual import on
+
+from wrkmon.core.youtube import SearchResult
+from wrkmon.data.models import HistoryEntry
+from wrkmon.ui.widgets.result_item import HistoryItem
+from wrkmon.ui.messages import TrackSelected, TrackQueued, StatusMessage
+
+
+class HistoryView(Vertical):
+    """History view - shows recently played tracks."""
+
+    BINDINGS = [
+        Binding("a", "queue_selected", "Add to Queue", show=True),
+        Binding("c", "clear_history", "Clear All", show=True),
+        Binding("r", "refresh", "Refresh", show=True),
+    ]
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.entries: list[HistoryEntry] = []
+
+    def compose(self) -> ComposeResult:
+        yield Static("HISTORY", id="view-title")
+
+        yield Static(
+            " #   Process                              Duration  Runs  Last Run",
+            id="list-header",
+        )
+
+        yield ListView(id="history-list")
+        yield Static("Loading history...", id="status-bar")
+
+    def on_mount(self) -> None:
+        """Load history on mount."""
+        self.load_history()
+
+    def load_history(self) -> None:
+        """Load play history from database."""
+        try:
+            db = self.app.database
+            self.entries = db.get_history(limit=100)
+            self._display_history()
+        except Exception as e:
+            self._update_status(f"Failed to load history: {e}")
+
+    def _display_history(self) -> None:
+        """Display history entries."""
+        list_view = self.query_one("#history-list", ListView)
+        list_view.clear()
+
+        if not self.entries:
+            self._update_status("No history yet")
+            return
+
+        for i, entry in enumerate(self.entries, 1):
+            track = entry.track
+            last_played = entry.played_at.strftime("%m-%d %H:%M")
+
+            list_view.append(
+                HistoryItem(
+                    title=track.title,
+                    duration=track.duration,
+                    play_count=entry.play_count,
+                    last_played=last_played,
+                    index=i,
+                    video_id=track.video_id,
+                    channel=track.channel,
+                )
+            )
+
+        total_plays = sum(e.play_count for e in self.entries)
+        self._update_status(f"{len(self.entries)} tracks, {total_plays} total plays")
+
+    def _update_status(self, message: str) -> None:
+        """Update status bar."""
+        try:
+            self.query_one("#status-bar", Static).update(message)
+        except Exception:
+            pass
+
+    def _get_selected(self) -> HistoryItem | None:
+        """Get the currently selected history item."""
+        list_view = self.query_one("#history-list", ListView)
+        if list_view.highlighted_child is None:
+            return None
+
+        item = list_view.highlighted_child
+        if isinstance(item, HistoryItem):
+            return item
+        return None
+
+    def _item_to_result(self, item: HistoryItem) -> SearchResult:
+        """Convert a history item to a SearchResult."""
+        return SearchResult(
+            video_id=item.video_id,
+            title=item.title,
+            channel=item.channel,
+            duration=item.duration,
+            view_count=0,
+        )
+
+    @on(ListView.Selected, "#history-list")
+    def handle_item_selected(self, event: ListView.Selected) -> None:
+        """Handle Enter key on a history item - play it."""
+        if isinstance(event.item, HistoryItem):
+            result = self._item_to_result(event.item)
+            self.post_message(TrackSelected(result))
+            self._update_status(f"Playing: {event.item.title[:40]}...")
+
+    def action_queue_selected(self) -> None:
+        """Add selected track to queue."""
+        item = self._get_selected()
+        if item:
+            result = self._item_to_result(item)
+            self.post_message(TrackQueued(result))
+            self._update_status(f"Queued: {item.title[:40]}...")
+
+    def action_clear_history(self) -> None:
+        """Clear all history."""
+        try:
+            db = self.app.database
+            count = db.clear_history()
+            self.entries = []
+            self._display_history()
+            self.post_message(StatusMessage(f"Cleared {count} entries", "info"))
+        except Exception as e:
+            self.post_message(StatusMessage(f"Error: {e}", "error"))
+
+    def action_refresh(self) -> None:
+        """Refresh history."""
+        self.load_history()
+        self.post_message(StatusMessage("History refreshed", "info"))