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

meeting_noter/ui/screens/recordings.py

@@ -0,0 +1,241 @@
+"""Recordings browser screen for Meeting Noter."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.screen import Screen
+from textual.widgets import Button, DataTable, Label, Static
+
+from meeting_noter.config import get_config
+from meeting_noter.output.writer import format_duration, format_size, get_audio_duration
+
+
+@dataclass
+class RecordingInfo:
+    """Information about a recording."""
+
+    filepath: Path
+    date: datetime
+    duration: Optional[float]
+    size: int
+    has_transcript: bool
+    is_favorite: bool
+
+
+def get_recordings_list(output_dir: Path, limit: int = 50) -> list[RecordingInfo]:
+    """Get list of recordings with metadata."""
+    config = get_config()
+
+    if not output_dir.exists():
+        return []
+
+    mp3_files = sorted(
+        output_dir.glob("*.mp3"),
+        key=lambda p: p.stat().st_mtime,
+        reverse=True,
+    )
+
+    # Get transcripts directory from config
+    transcripts_dir = config.transcripts_dir
+
+    recordings = []
+    for mp3 in mp3_files[:limit]:
+        stat = mp3.stat()
+        transcript_name = mp3.stem + ".txt"
+
+        # Check for transcript in transcripts directory
+        transcript_path = transcripts_dir / transcript_name
+        has_transcript = transcript_path.exists()
+
+        recordings.append(
+            RecordingInfo(
+                filepath=mp3,
+                date=datetime.fromtimestamp(stat.st_mtime),
+                duration=get_audio_duration(mp3),
+                size=stat.st_size,
+                has_transcript=has_transcript,
+                is_favorite=config.is_favorite(transcript_name),
+            )
+        )
+
+    return recordings
+
+
+class RecordingsScreen(Screen):
+    """Recordings browser screen."""
+
+    BINDINGS = [
+        ("t", "transcribe", "Transcribe"),
+        ("enter", "view", "View"),
+        ("f", "toggle_favorite", "Favorite"),
+        ("r", "refresh", "Refresh"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        """Compose the recordings screen layout."""
+        yield Container(
+            Static("[bold]Recordings[/bold]", classes="title"),
+            Static("", classes="spacer"),
+            DataTable(id="recordings-table", cursor_type="row"),
+            Static("", classes="spacer"),
+            Horizontal(
+                Button("View", id="view-btn"),
+                Button("Transcribe", id="transcribe-btn", variant="primary"),
+                Button("Toggle Favorite", id="favorite-btn"),
+                Button("Refresh", id="refresh-btn"),
+                classes="button-row",
+            ),
+            Label("", id="status-label"),
+            id="recordings-container",
+        )
+
+    def on_mount(self) -> None:
+        """Load recordings on mount."""
+        self._setup_table()
+        self._load_recordings()
+
+    def _setup_table(self) -> None:
+        """Set up the recordings table."""
+        table = self.query_one("#recordings-table", DataTable)
+        table.add_columns("★", "Date", "Duration", "Size", "Transcript", "File")
+
+    def _load_recordings(self) -> None:
+        """Load recordings into the table."""
+        config = get_config()
+        table = self.query_one("#recordings-table", DataTable)
+        status = self.query_one("#status-label", Label)
+
+        table.clear()
+
+        recordings = get_recordings_list(config.recordings_dir)
+
+        if not recordings:
+            status.update("[yellow]No recordings found[/yellow]")
+            return
+
+        for rec in recordings:
+            star = "★" if rec.is_favorite else ""
+            date_str = rec.date.strftime("%Y-%m-%d %H:%M")
+            duration_str = format_duration(rec.duration) if rec.duration else "?"
+            size_str = format_size(rec.size)
+            transcript_str = "Yes" if rec.has_transcript else "No"
+
+            table.add_row(
+                star,
+                date_str,
+                duration_str,
+                size_str,
+                transcript_str,
+                rec.filepath.name,
+                key=str(rec.filepath),
+            )
+
+        status.update(f"[dim]{len(recordings)} recordings[/dim]")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        button_id = event.button.id
+
+        if button_id == "view-btn":
+            self.action_view()
+        elif button_id == "transcribe-btn":
+            self.action_transcribe()
+        elif button_id == "favorite-btn":
+            self.action_toggle_favorite()
+        elif button_id == "refresh-btn":
+            self.action_refresh()
+
+    def _get_selected_filepath(self) -> Optional[Path]:
+        """Get the filepath of the currently selected recording."""
+        table = self.query_one("#recordings-table", DataTable)
+
+        if table.row_count == 0:
+            return None
+
+        row_key = table.coordinate_to_cell_key(table.cursor_coordinate).row_key
+        if row_key:
+            return Path(row_key.value)
+        return None
+
+    def action_view(self) -> None:
+        """View the selected transcript."""
+        filepath = self._get_selected_filepath()
+        if not filepath:
+            self.notify("No recording selected", severity="warning")
+            return
+
+        config = get_config()
+        transcript_name = filepath.stem + ".txt"
+        transcript = config.transcripts_dir / transcript_name
+
+        if not transcript.exists():
+            self.notify("No transcript available. Transcribe first.", severity="warning")
+            return
+
+        # Push the viewer screen with the transcript path
+        from meeting_noter.ui.screens.viewer import ViewerScreen
+
+        self.app.push_screen(ViewerScreen(transcript))
+
+    def action_transcribe(self) -> None:
+        """Transcribe the selected recording."""
+        import subprocess
+        import sys
+
+        filepath = self._get_selected_filepath()
+        if not filepath:
+            self.notify("No recording selected", severity="warning")
+            return
+
+        config = get_config()
+        transcript_name = filepath.stem + ".txt"
+        transcript = config.transcripts_dir / transcript_name
+
+        if transcript.exists():
+            self.notify("Transcript already exists", severity="warning")
+            return
+
+        # Run transcription in background
+        subprocess.Popen(
+            [
+                sys.executable,
+                "-m",
+                "meeting_noter.cli",
+                "transcribe",
+                str(filepath),
+            ],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+        self.notify(f"Transcribing: {filepath.name}", severity="information")
+
+    def action_toggle_favorite(self) -> None:
+        """Toggle favorite status for the selected recording."""
+        filepath = self._get_selected_filepath()
+        if not filepath:
+            self.notify("No recording selected", severity="warning")
+            return
+
+        config = get_config()
+        transcript_name = filepath.with_suffix(".txt").name
+
+        if config.is_favorite(transcript_name):
+            config.remove_favorite(transcript_name)
+            self.notify(f"Removed from favorites: {transcript_name}")
+        else:
+            config.add_favorite(transcript_name)
+            self.notify(f"Added to favorites: {transcript_name}")
+
+        self._load_recordings()
+
+    def action_refresh(self) -> None:
+        """Refresh the recordings list."""
+        self._load_recordings()
+        self.notify("Refreshed")

meeting_noter/ui/screens/search.py

@@ -0,0 +1,191 @@
+"""Search screen for Meeting Noter."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal, Vertical
+from textual.screen import Screen
+from textual.widgets import Button, Checkbox, Input, Label, ListView, ListItem, Static
+
+from meeting_noter.config import get_config
+from meeting_noter.output.searcher import _search_file, FileSearchResult
+
+
+class SearchResultItem(ListItem):
+    """A search result list item."""
+
+    def __init__(self, filepath: Path, match_text: str, timestamp: Optional[str] = None):
+        super().__init__()
+        self.filepath = filepath
+        self.match_text = match_text
+        self.timestamp = timestamp
+
+    def compose(self) -> ComposeResult:
+        """Compose the list item."""
+        if self.timestamp:
+            yield Static(f"[cyan][{self.timestamp}][/cyan] {self.match_text[:70]}...")
+        else:
+            yield Static(f"{self.match_text[:80]}...")
+
+
+class SearchScreen(Screen):
+    """Search screen."""
+
+    BINDINGS = [
+        ("slash", "focus_search", "Search"),
+        ("enter", "view_selected", "View"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        """Compose the search screen layout."""
+        yield Container(
+            Static("[bold]Search Transcripts[/bold]", classes="title"),
+            Static("", classes="spacer"),
+            Horizontal(
+                Input(placeholder="Enter search query...", id="search-input"),
+                Button("Search", id="search-btn", variant="primary"),
+                classes="search-row",
+            ),
+            Horizontal(
+                Checkbox("Case sensitive", id="case-sensitive"),
+                classes="options-row",
+            ),
+            Static("", classes="spacer"),
+            Label("", id="results-header"),
+            ListView(id="results-list"),
+            Label("", id="results-footer"),
+            id="search-container",
+        )
+
+    def on_mount(self) -> None:
+        """Focus search input on mount."""
+        self.query_one("#search-input", Input).focus()
+
+    def action_focus_search(self) -> None:
+        """Focus the search input."""
+        self.query_one("#search-input", Input).focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        if event.button.id == "search-btn":
+            self._do_search()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Handle Enter in search input."""
+        if event.input.id == "search-input":
+            self._do_search()
+
+    def _do_search(self) -> None:
+        """Perform the search."""
+        config = get_config()
+        query = self.query_one("#search-input", Input).value.strip()
+        case_sensitive = self.query_one("#case-sensitive", Checkbox).value
+
+        results_list = self.query_one("#results-list", ListView)
+        results_header = self.query_one("#results-header", Label)
+        results_footer = self.query_one("#results-footer", Label)
+
+        results_list.clear()
+
+        if not query:
+            results_header.update("[yellow]Enter a search query[/yellow]")
+            results_footer.update("")
+            return
+
+        transcripts_dir = config.transcripts_dir
+        if not transcripts_dir.exists():
+            results_header.update("[red]Transcripts directory not found[/red]")
+            results_footer.update("")
+            return
+
+        # Find all transcript files
+        txt_files = sorted(
+            transcripts_dir.glob("*.txt"),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )
+
+        if not txt_files:
+            results_header.update("[yellow]No transcripts found[/yellow]")
+            results_footer.update("")
+            return
+
+        # Search all files
+        results: list[FileSearchResult] = []
+        for txt_file in txt_files:
+            result = _search_file(txt_file, query, case_sensitive)
+            if result:
+                results.append(result)
+
+        if not results:
+            results_header.update(f"[yellow]No results for '{query}'[/yellow]")
+            results_footer.update(f"[dim]Searched {len(txt_files)} transcripts[/dim]")
+            return
+
+        # Sort by match count
+        results.sort(key=lambda r: r.match_count, reverse=True)
+
+        # Count totals
+        total_matches = sum(r.match_count for r in results)
+        total_files = len(results)
+
+        results_header.update(
+            f"[green]Found {total_matches} matches in {total_files} transcripts[/green]"
+        )
+
+        # Add results to list (limit for performance)
+        max_items = 50
+        items_added = 0
+
+        for result in results:
+            if items_added >= max_items:
+                break
+
+            # Add file header
+            results_list.append(
+                ListItem(
+                    Static(f"[bold green]{result.filepath.name}[/bold green] ({result.match_count} matches)")
+                )
+            )
+
+            # Add matches (limit per file)
+            for match in result.matches[:5]:
+                results_list.append(
+                    SearchResultItem(
+                        result.filepath,
+                        match.line.strip(),
+                        match.timestamp,
+                    )
+                )
+                items_added += 1
+                if items_added >= max_items:
+                    break
+
+        if total_matches > max_items:
+            results_footer.update(
+                f"[dim]Showing {items_added} of {total_matches} matches. "
+                f"Searched {len(txt_files)} transcripts.[/dim]"
+            )
+        else:
+            results_footer.update(f"[dim]Searched {len(txt_files)} transcripts[/dim]")
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        """Handle list item selection."""
+        item = event.item
+        if isinstance(item, SearchResultItem):
+            from meeting_noter.ui.screens.viewer import ViewerScreen
+
+            self.app.push_screen(ViewerScreen(item.filepath))
+
+    def action_view_selected(self) -> None:
+        """View the selected result's transcript."""
+        results_list = self.query_one("#results-list", ListView)
+        if results_list.highlighted_child:
+            item = results_list.highlighted_child
+            if isinstance(item, SearchResultItem):
+                from meeting_noter.ui.screens.viewer import ViewerScreen
+
+                self.app.push_screen(ViewerScreen(item.filepath))

meeting_noter/ui/screens/settings.py

@@ -0,0 +1,184 @@
+"""Settings screen for Meeting Noter."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal, Vertical
+from textual.screen import Screen
+from textual.widgets import Button, Input, Label, Select, Static, Switch
+
+from meeting_noter.config import get_config
+
+
+WHISPER_MODELS = [
+    ("tiny.en (fastest)", "tiny.en"),
+    ("base.en (balanced)", "base.en"),
+    ("small.en (better)", "small.en"),
+    ("medium.en (high quality)", "medium.en"),
+    ("large-v3 (best, multilingual)", "large-v3"),
+]
+
+
+class SettingsScreen(Screen):
+    """Settings configuration screen."""
+
+    BINDINGS = [
+        ("s", "save", "Save"),
+        ("escape", "go_back", "Back"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        """Compose the settings screen layout."""
+        config = get_config()
+
+        yield Container(
+            Static("[bold]Settings[/bold]", classes="title"),
+            Static("", classes="spacer"),
+            Vertical(
+                # Directories
+                Static("[dim]Directories[/dim]", classes="section-header"),
+                Horizontal(
+                    Label("Recordings: ", classes="setting-label"),
+                    Input(
+                        str(config.recordings_dir),
+                        id="recordings-dir",
+                        classes="setting-input",
+                    ),
+                    classes="setting-row",
+                ),
+                Horizontal(
+                    Label("Transcripts: ", classes="setting-label"),
+                    Input(
+                        str(config.transcripts_dir),
+                        id="transcripts-dir",
+                        classes="setting-input",
+                    ),
+                    classes="setting-row",
+                ),
+                Static("", classes="spacer"),
+                # Whisper model
+                Static("[dim]Transcription[/dim]", classes="section-header"),
+                Horizontal(
+                    Label("Whisper model: ", classes="setting-label"),
+                    Select(
+                        WHISPER_MODELS,
+                        value=config.whisper_model,
+                        id="whisper-model",
+                    ),
+                    classes="setting-row",
+                ),
+                Static("", classes="spacer"),
+                # Toggles
+                Static("[dim]Options[/dim]", classes="section-header"),
+                Horizontal(
+                    Label("Auto-transcribe: ", classes="setting-label"),
+                    Switch(value=config.auto_transcribe, id="auto-transcribe"),
+                    classes="setting-row",
+                ),
+                Horizontal(
+                    Label("Capture system audio: ", classes="setting-label"),
+                    Switch(value=config.capture_system_audio, id="capture-system-audio"),
+                    classes="setting-row",
+                ),
+                Horizontal(
+                    Label("Auto-update: ", classes="setting-label"),
+                    Switch(value=config.auto_update, id="auto-update"),
+                    classes="setting-row",
+                ),
+                Static("", classes="spacer"),
+                # Silence timeout
+                Horizontal(
+                    Label("Silence timeout (min): ", classes="setting-label"),
+                    Input(
+                        str(config.silence_timeout),
+                        id="silence-timeout",
+                        type="integer",
+                    ),
+                    classes="setting-row",
+                ),
+                classes="settings-form",
+            ),
+            Static("", classes="spacer"),
+            Horizontal(
+                Button("Save", id="save-btn", variant="success"),
+                Button("Reset", id="reset-btn"),
+                Button("Back", id="back-btn"),
+                classes="button-row",
+            ),
+            Label("", id="status-label"),
+            id="settings-container",
+        )
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        button_id = event.button.id
+
+        if button_id == "save-btn":
+            self.action_save()
+        elif button_id == "reset-btn":
+            self._reset_to_current()
+        elif button_id == "back-btn":
+            self.action_go_back()
+
+    def action_save(self) -> None:
+        """Save settings."""
+        from pathlib import Path
+
+        config = get_config()
+
+        try:
+            # Get values from inputs
+            recordings_dir = self.query_one("#recordings-dir", Input).value
+            transcripts_dir = self.query_one("#transcripts-dir", Input).value
+            whisper_model = self.query_one("#whisper-model", Select).value
+            auto_transcribe = self.query_one("#auto-transcribe", Switch).value
+            capture_system_audio = self.query_one("#capture-system-audio", Switch).value
+            auto_update = self.query_one("#auto-update", Switch).value
+            silence_timeout = self.query_one("#silence-timeout", Input).value
+
+            # Validate and set
+            recordings_path = Path(recordings_dir).expanduser()
+            transcripts_path = Path(transcripts_dir).expanduser()
+
+            # Create directories if they don't exist
+            recordings_path.mkdir(parents=True, exist_ok=True)
+            transcripts_path.mkdir(parents=True, exist_ok=True)
+
+            # Update config
+            config.recordings_dir = recordings_path
+            config.transcripts_dir = transcripts_path
+            config.whisper_model = whisper_model
+            config.auto_transcribe = auto_transcribe
+            config.capture_system_audio = capture_system_audio
+            config.auto_update = auto_update
+            config.silence_timeout = int(silence_timeout) if silence_timeout else 5
+
+            config.save()
+
+            self.notify("Settings saved", severity="information")
+            self.query_one("#status-label", Label).update(
+                "[green]Settings saved successfully[/green]"
+            )
+
+        except Exception as e:
+            self.notify(f"Error saving settings: {e}", severity="error")
+            self.query_one("#status-label", Label).update(f"[red]Error: {e}[/red]")
+
+    def _reset_to_current(self) -> None:
+        """Reset form to current config values."""
+        config = get_config()
+        config.load()  # Reload from disk
+
+        self.query_one("#recordings-dir", Input).value = str(config.recordings_dir)
+        self.query_one("#transcripts-dir", Input).value = str(config.transcripts_dir)
+        self.query_one("#whisper-model", Select).value = config.whisper_model
+        self.query_one("#auto-transcribe", Switch).value = config.auto_transcribe
+        self.query_one("#capture-system-audio", Switch).value = config.capture_system_audio
+        self.query_one("#auto-update", Switch).value = config.auto_update
+        self.query_one("#silence-timeout", Input).value = str(config.silence_timeout)
+
+        self.notify("Reset to saved values")
+
+    def action_go_back(self) -> None:
+        """Go back to the previous screen."""
+        self.app.pop_screen()