meeting-noter 1.3.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

meeting_noter/ui/app.py

@@ -0,0 +1,68 @@
+"""Main Textual application for Meeting Noter."""
+
+from __future__ import annotations
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.widgets import Footer, Header
+
+from meeting_noter.ui.screens.main import MainScreen
+from meeting_noter.ui.screens.recordings import RecordingsScreen
+from meeting_noter.ui.screens.search import SearchScreen
+from meeting_noter.ui.screens.settings import SettingsScreen
+from meeting_noter.ui.screens.logs import LogsScreen
+
+
+class MeetingNoterApp(App):
+    """Meeting Noter Terminal UI Application."""
+
+    TITLE = "Meeting Noter"
+    CSS_PATH = "styles/app.tcss"
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("question_mark", "help", "Help", key_display="?"),
+        Binding("1", "switch_screen('main')", "Dashboard", show=True),
+        Binding("2", "switch_screen('recordings')", "Recordings", show=True),
+        Binding("3", "switch_screen('search')", "Search", show=True),
+        Binding("4", "switch_screen('settings')", "Settings", show=True),
+        Binding("5", "switch_screen('logs')", "Logs", show=True),
+        Binding("escape", "go_back", "Back", show=False),
+    ]
+
+    SCREENS = {
+        "main": MainScreen,
+        "recordings": RecordingsScreen,
+        "search": SearchScreen,
+        "settings": SettingsScreen,
+        "logs": LogsScreen,
+    }
+
+    def compose(self) -> ComposeResult:
+        """Compose the app layout."""
+        yield Header()
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Handle app mount - show the main screen."""
+        self.push_screen("main")
+
+    def action_switch_screen(self, screen_name: str) -> None:
+        """Switch to a named screen."""
+        # Pop all screens except the base and push the new one
+        while len(self.screen_stack) > 1:
+            self.pop_screen()
+        self.push_screen(screen_name)
+
+    def action_go_back(self) -> None:
+        """Go back to the previous screen."""
+        if len(self.screen_stack) > 1:
+            self.pop_screen()
+
+    def action_help(self) -> None:
+        """Show help information."""
+        self.notify(
+            "Keys: 1-5 switch screens, q quit, ? help",
+            title="Meeting Noter Help",
+            timeout=5,
+        )

meeting_noter/ui/screens/__init__.py

@@ -0,0 +1,17 @@
+"""UI Screens for Meeting Noter."""
+
+from meeting_noter.ui.screens.main import MainScreen
+from meeting_noter.ui.screens.recordings import RecordingsScreen
+from meeting_noter.ui.screens.search import SearchScreen
+from meeting_noter.ui.screens.viewer import ViewerScreen
+from meeting_noter.ui.screens.settings import SettingsScreen
+from meeting_noter.ui.screens.logs import LogsScreen
+
+__all__ = [
+    "MainScreen",
+    "RecordingsScreen",
+    "SearchScreen",
+    "ViewerScreen",
+    "SettingsScreen",
+    "LogsScreen",
+]

meeting_noter/ui/screens/logs.py

@@ -0,0 +1,166 @@
+"""Logs viewer screen for Meeting Noter."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.screen import Screen
+from textual.widgets import Button, Label, RichLog, Static, Switch
+
+
+LOG_FILE = Path.home() / ".meeting-noter.log"
+
+
+class LogsScreen(Screen):
+    """Logs viewer screen."""
+
+    BINDINGS = [
+        ("l", "toggle_follow", "Follow"),
+        ("c", "clear_display", "Clear"),
+        ("r", "refresh", "Refresh"),
+        ("escape", "go_back", "Back"),
+    ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._follow_mode = True
+        self._last_size = 0
+
+    def compose(self) -> ComposeResult:
+        """Compose the logs screen layout."""
+        yield Container(
+            Static("[bold]Logs[/bold]", classes="title"),
+            Label(f"[dim]{LOG_FILE}[/dim]", id="log-path"),
+            Static("", classes="spacer"),
+            RichLog(id="log-content", highlight=True, markup=True),
+            Static("", classes="spacer"),
+            Horizontal(
+                Label("Follow: "),
+                Switch(value=True, id="follow-switch"),
+                Button("Refresh", id="refresh-btn"),
+                Button("Clear", id="clear-btn"),
+                Button("Back", id="back-btn"),
+                classes="button-row",
+            ),
+            id="logs-container",
+        )
+
+    def on_mount(self) -> None:
+        """Start log refresh on mount."""
+        self._load_logs()
+        self.set_interval(1.0, self._check_for_updates)
+
+    def _load_logs(self, lines: int = 100) -> None:
+        """Load the last N lines from the log file."""
+        log_content = self.query_one("#log-content", RichLog)
+
+        if not LOG_FILE.exists():
+            log_content.write("[yellow]No log file found[/yellow]")
+            return
+
+        try:
+            content = LOG_FILE.read_text()
+            all_lines = content.splitlines()
+            recent_lines = all_lines[-lines:] if len(all_lines) > lines else all_lines
+
+            log_content.clear()
+            for line in recent_lines:
+                # Color-code different log levels
+                if "Error" in line or "error" in line:
+                    log_content.write(f"[red]{line}[/red]")
+                elif "Warning" in line or "warning" in line:
+                    log_content.write(f"[yellow]{line}[/yellow]")
+                elif "Recording started" in line:
+                    log_content.write(f"[green]{line}[/green]")
+                elif "Recording saved" in line:
+                    log_content.write(f"[cyan]{line}[/cyan]")
+                else:
+                    log_content.write(line)
+
+            self._last_size = LOG_FILE.stat().st_size
+
+        except Exception as e:
+            log_content.write(f"[red]Error reading log: {e}[/red]")
+
+    def _check_for_updates(self) -> None:
+        """Check for new log content if in follow mode."""
+        if not self._follow_mode:
+            return
+
+        follow_switch = self.query_one("#follow-switch", Switch)
+        self._follow_mode = follow_switch.value
+
+        if not self._follow_mode:
+            return
+
+        if not LOG_FILE.exists():
+            return
+
+        try:
+            current_size = LOG_FILE.stat().st_size
+            if current_size > self._last_size:
+                # Read new content
+                with open(LOG_FILE, "r") as f:
+                    f.seek(self._last_size)
+                    new_content = f.read()
+
+                log_content = self.query_one("#log-content", RichLog)
+                for line in new_content.splitlines():
+                    if line.strip():
+                        if "Error" in line or "error" in line:
+                            log_content.write(f"[red]{line}[/red]")
+                        elif "Warning" in line or "warning" in line:
+                            log_content.write(f"[yellow]{line}[/yellow]")
+                        elif "Recording started" in line:
+                            log_content.write(f"[green]{line}[/green]")
+                        elif "Recording saved" in line:
+                            log_content.write(f"[cyan]{line}[/cyan]")
+                        else:
+                            log_content.write(line)
+
+                self._last_size = current_size
+
+        except Exception:
+            pass
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        button_id = event.button.id
+
+        if button_id == "refresh-btn":
+            self.action_refresh()
+        elif button_id == "clear-btn":
+            self.action_clear_display()
+        elif button_id == "back-btn":
+            self.action_go_back()
+
+    def on_switch_changed(self, event: Switch.Changed) -> None:
+        """Handle follow switch changes."""
+        if event.switch.id == "follow-switch":
+            self._follow_mode = event.value
+            if event.value:
+                self.notify("Follow mode enabled")
+            else:
+                self.notify("Follow mode disabled")
+
+    def action_toggle_follow(self) -> None:
+        """Toggle follow mode."""
+        switch = self.query_one("#follow-switch", Switch)
+        switch.value = not switch.value
+
+    def action_clear_display(self) -> None:
+        """Clear the log display."""
+        log_content = self.query_one("#log-content", RichLog)
+        log_content.clear()
+        self.notify("Display cleared")
+
+    def action_refresh(self) -> None:
+        """Refresh the log display."""
+        self._load_logs()
+        self.notify("Refreshed")
+
+    def action_go_back(self) -> None:
+        """Go back to the previous screen."""
+        self.app.pop_screen()

meeting_noter/ui/screens/main.py

@@ -0,0 +1,346 @@
+"""Main dashboard screen for Meeting Noter."""
+
+from __future__ import annotations
+
+import os
+import signal
+from pathlib import Path
+from typing import Optional, Tuple
+
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal, Vertical, Center
+from textual.screen import Screen
+from textual.widgets import Button, Input, Label, RichLog, Static, Switch
+
+from meeting_noter.config import get_config, generate_meeting_name
+from meeting_noter.daemon import read_pid_file, is_process_running
+
+
+# PID file paths
+DEFAULT_PID_FILE = Path.home() / ".meeting-noter.pid"
+WATCHER_PID_FILE = Path.home() / ".meeting-noter-watcher.pid"
+
+
+class StatusDisplay(Static):
+    """Widget to display current status."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._status = "Checking..."
+
+    def on_mount(self) -> None:
+        """Start status refresh timer."""
+        self.set_interval(2.0, self.refresh_status)
+        self.refresh_status()
+
+    def refresh_status(self) -> None:
+        """Refresh the status display."""
+        watcher_running = self._check_watcher()
+        daemon_running, recording_name = self._check_daemon()
+
+        if daemon_running:
+            status_icon = "[red]●[/red]"
+            status_text = f"Recording: {recording_name or 'In progress'}"
+        elif watcher_running:
+            status_icon = "[green]●[/green]"
+            status_text = "Ready (watcher active)"
+        else:
+            status_icon = "[dim]●[/dim]"
+            status_text = "Stopped"
+
+        self.update(
+            f"{status_icon} {status_text}\n\n"
+            f"[dim]Watcher:[/dim] {'running' if watcher_running else 'stopped'}\n"
+            f"[dim]Recorder:[/dim] {'recording' if daemon_running else 'idle'}"
+        )
+
+        # Notify parent screen about recording state
+        try:
+            screen = self.screen
+            if hasattr(screen, "_update_recording_state"):
+                screen._update_recording_state(daemon_running)
+        except Exception:
+            pass
+
+    def _check_watcher(self) -> bool:
+        """Check if watcher is running."""
+        if WATCHER_PID_FILE.exists():
+            try:
+                pid = int(WATCHER_PID_FILE.read_text().strip())
+                os.kill(pid, 0)
+                return True
+            except (ProcessLookupError, ValueError, FileNotFoundError):
+                pass
+        return False
+
+    def _check_daemon(self) -> Tuple[bool, Optional[str]]:
+        """Check if daemon is running and get recording name."""
+        daemon_pid = read_pid_file(DEFAULT_PID_FILE)
+        if daemon_pid and is_process_running(daemon_pid):
+            recording_name = self._get_current_recording_name()
+            return True, recording_name
+        return False, None
+
+    def _get_current_recording_name(self) -> Optional[str]:
+        """Get the name of the current recording from the log file."""
+        log_path = Path.home() / ".meeting-noter.log"
+        if not log_path.exists():
+            return None
+
+        try:
+            with open(log_path, "r") as f:
+                lines = f.readlines()
+
+            for line in reversed(lines[-50:]):
+                if "Recording started:" in line:
+                    parts = line.split("Recording started:")
+                    if len(parts) > 1:
+                        filename = parts[1].strip().replace(".mp3", "")
+                        name_parts = filename.split("_", 2)
+                        if len(name_parts) >= 3:
+                            return name_parts[2]
+                        return filename
+                elif "Recording saved:" in line or "Recording discarded" in line:
+                    break
+            return None
+        except Exception:
+            return None
+
+
+class LiveTranscriptDisplay(RichLog):
+    """Widget to display live transcription."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, highlight=True, markup=True, **kwargs)
+        self._live_file: Optional[Path] = None
+        self._last_content = ""
+        self._is_recording = False
+
+    def on_mount(self) -> None:
+        """Start watching for live transcript updates."""
+        self.set_interval(0.5, self._check_live_transcript)
+
+    def set_recording(self, is_recording: bool) -> None:
+        """Set the recording state."""
+        self._is_recording = is_recording
+        if not is_recording:
+            self._live_file = None
+            self._last_content = ""
+
+    def _check_live_transcript(self) -> None:
+        """Check for live transcript updates."""
+        if not self._is_recording:
+            return
+
+        config = get_config()
+        live_dir = config.recordings_dir / "live"
+
+        if not live_dir.exists():
+            return
+
+        # Find the most recent live file
+        live_files = sorted(
+            live_dir.glob("*.live.txt"),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )
+
+        if not live_files:
+            return
+
+        live_file = live_files[0]
+
+        # Read and display new content
+        try:
+            content = live_file.read_text()
+            if len(content) > len(self._last_content):
+                new_content = content[len(self._last_content):]
+                for line in new_content.splitlines():
+                    if line.strip() and line.startswith("["):
+                        self.write(f"[cyan]{line}[/cyan]")
+                self._last_content = content
+        except Exception:
+            pass
+
+
+class MainScreen(Screen):
+    """Main dashboard screen."""
+
+    BINDINGS = [
+        ("r", "toggle_recording", "Record"),
+    ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._is_recording = False
+
+    def compose(self) -> ComposeResult:
+        """Compose the main screen layout."""
+        yield Container(
+            Static("[bold]Meeting Noter[/bold]", classes="title"),
+            Static("", classes="spacer"),
+            StatusDisplay(id="status"),
+            Static("", classes="spacer"),
+            Center(
+                Vertical(
+                    Horizontal(
+                        Label("Meeting name:", classes="input-label"),
+                        Input(
+                            placeholder=generate_meeting_name(),
+                            id="meeting-name",
+                            classes="meeting-input",
+                        ),
+                        classes="centered-input-row",
+                    ),
+                    Horizontal(
+                        Label("Live transcription:", classes="input-label"),
+                        Switch(value=True, id="live-transcription"),
+                        classes="centered-switch-row",
+                    ),
+                    classes="input-section",
+                ),
+            ),
+            Static("", classes="spacer"),
+            Center(
+                Horizontal(
+                    Button("Start Recording", id="record-btn", variant="success"),
+                    Button("Stop", id="stop-btn", variant="error"),
+                    classes="centered-button-row",
+                ),
+            ),
+            Static("", classes="spacer"),
+            Static("[dim]Live Transcription[/dim]", id="live-header", classes="section-header"),
+            LiveTranscriptDisplay(id="live-transcript"),
+            Static("", classes="spacer"),
+            Static("[dim]Quick Navigation[/dim]", classes="section-header"),
+            Center(
+                Horizontal(
+                    Button("Recordings", id="nav-recordings"),
+                    Button("Search", id="nav-search"),
+                    Button("Settings", id="nav-settings"),
+                    Button("Logs", id="nav-logs"),
+                    classes="centered-button-row",
+                ),
+            ),
+            id="main-container",
+        )
+
+    def _update_recording_state(self, is_recording: bool) -> None:
+        """Update UI based on recording state."""
+        if is_recording != self._is_recording:
+            self._is_recording = is_recording
+            live_display = self.query_one("#live-transcript", LiveTranscriptDisplay)
+            live_switch = self.query_one("#live-transcription", Switch)
+
+            if is_recording and live_switch.value:
+                live_display.set_recording(True)
+                live_display.clear()
+                live_display.write("[dim]Waiting for transcription...[/dim]")
+            else:
+                live_display.set_recording(False)
+
+    def action_toggle_recording(self) -> None:
+        """Toggle recording state."""
+        daemon_pid = read_pid_file(DEFAULT_PID_FILE)
+        if daemon_pid and is_process_running(daemon_pid):
+            self._on_stop_button()
+        else:
+            self._on_record_button()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        button_id = event.button.id
+
+        if button_id == "record-btn":
+            self._on_record_button()
+        elif button_id == "stop-btn":
+            self._on_stop_button()
+        elif button_id == "nav-recordings":
+            self.app.action_switch_screen("recordings")
+        elif button_id == "nav-search":
+            self.app.action_switch_screen("search")
+        elif button_id == "nav-settings":
+            self.app.action_switch_screen("settings")
+        elif button_id == "nav-logs":
+            self.app.action_switch_screen("logs")
+
+    def _on_record_button(self) -> None:
+        """Handle record button press."""
+        import subprocess
+        import sys
+
+        # Check if already recording
+        daemon_pid = read_pid_file(DEFAULT_PID_FILE)
+        if daemon_pid and is_process_running(daemon_pid):
+            self.notify("Already recording. Stop first.", severity="warning")
+            return
+
+        # Get meeting name
+        name_input = self.query_one("#meeting-name", Input)
+        meeting_name = name_input.value.strip() or generate_meeting_name()
+
+        # Clear live transcript display
+        live_display = self.query_one("#live-transcript", LiveTranscriptDisplay)
+        live_display.clear()
+        live_display.write(f"[green]Starting recording: {meeting_name}[/green]")
+
+        # Start recording
+        subprocess.Popen(
+            [sys.executable, "-m", "meeting_noter.cli", "daemon", "--name", meeting_name],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+        self.notify(f"Recording started: {meeting_name}", severity="information")
+
+        # Clear the input
+        name_input.value = ""
+
+        # Refresh status
+        self.query_one("#status", StatusDisplay).refresh_status()
+
+    def _on_stop_button(self) -> None:
+        """Handle stop button press - gracefully stop daemon."""
+        # Get daemon PID and send SIGTERM for graceful shutdown
+        daemon_pid = read_pid_file(DEFAULT_PID_FILE)
+        watcher_pid = None
+
+        if WATCHER_PID_FILE.exists():
+            try:
+                watcher_pid = int(WATCHER_PID_FILE.read_text().strip())
+            except (ValueError, FileNotFoundError):
+                pass
+
+        stopped = []
+
+        # Stop daemon gracefully (allows auto-transcribe to run)
+        if daemon_pid and is_process_running(daemon_pid):
+            try:
+                os.kill(daemon_pid, signal.SIGTERM)
+                stopped.append("recording")
+                self.notify("Stopping recording (will auto-transcribe if enabled)...", severity="information")
+            except ProcessLookupError:
+                pass
+
+        # Stop watcher
+        if watcher_pid:
+            try:
+                os.kill(watcher_pid, signal.SIGTERM)
+                stopped.append("watcher")
+            except ProcessLookupError:
+                pass
+            WATCHER_PID_FILE.unlink(missing_ok=True)
+
+        # Update live display
+        live_display = self.query_one("#live-transcript", LiveTranscriptDisplay)
+        live_display.set_recording(False)
+        if stopped:
+            live_display.write(f"\n[yellow]Stopped: {', '.join(stopped)}[/yellow]")
+
+        if not stopped:
+            self.notify("No processes running", severity="warning")
+        else:
+            self.notify(f"Stopped: {', '.join(stopped)}", severity="information")
+
+        # Refresh status after a short delay
+        self.set_timer(1.0, lambda: self.query_one("#status", StatusDisplay).refresh_status())