meeting-noter 1.2.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

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()

meeting_noter/ui/screens/viewer.py

@@ -0,0 +1,116 @@
+"""Transcript viewer screen for Meeting Noter."""
+
+from __future__ import annotations
+
+from datetime import datetime
+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, Static, TextArea
+
+from meeting_noter.config import get_config
+
+
+class ViewerScreen(Screen):
+    """Transcript viewer screen."""
+
+    BINDINGS = [
+        ("f", "toggle_favorite", "Favorite"),
+        ("escape", "go_back", "Back"),
+    ]
+
+    def __init__(self, transcript_path: Path, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.transcript_path = transcript_path
+
+    def compose(self) -> ComposeResult:
+        """Compose the viewer screen layout."""
+        config = get_config()
+        is_favorite = config.is_favorite(self.transcript_path.name)
+        star = "★ " if is_favorite else ""
+
+        yield Container(
+            Static(
+                f"[bold]{star}{self.transcript_path.name}[/bold]",
+                classes="title",
+            ),
+            Label("", id="file-info"),
+            Static("", classes="spacer"),
+            TextArea(id="transcript-content", read_only=True),
+            Static("", classes="spacer"),
+            Horizontal(
+                Button(
+                    "★ Favorite" if not is_favorite else "☆ Unfavorite",
+                    id="favorite-btn",
+                    variant="warning" if is_favorite else "default",
+                ),
+                Button("Back", id="back-btn"),
+                classes="button-row",
+            ),
+            id="viewer-container",
+        )
+
+    def on_mount(self) -> None:
+        """Load transcript content on mount."""
+        self._load_transcript()
+
+    def _load_transcript(self) -> None:
+        """Load the transcript content."""
+        info_label = self.query_one("#file-info", Label)
+        content_area = self.query_one("#transcript-content", TextArea)
+
+        if not self.transcript_path.exists():
+            info_label.update("[red]File not found[/red]")
+            content_area.text = "Transcript file does not exist."
+            return
+
+        # Get file info
+        stat = self.transcript_path.stat()
+        mod_time = datetime.fromtimestamp(stat.st_mtime)
+        date_str = mod_time.strftime("%Y-%m-%d %H:%M")
+        size_kb = stat.st_size / 1024
+
+        info_label.update(f"[dim]Modified: {date_str} | Size: {size_kb:.1f} KB[/dim]")
+
+        # Load content
+        try:
+            content = self.transcript_path.read_text(encoding="utf-8")
+            content_area.text = content
+        except Exception as e:
+            content_area.text = f"Error loading file: {e}"
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        if event.button.id == "favorite-btn":
+            self.action_toggle_favorite()
+        elif event.button.id == "back-btn":
+            self.action_go_back()
+
+    def action_toggle_favorite(self) -> None:
+        """Toggle favorite status."""
+        config = get_config()
+        filename = self.transcript_path.name
+
+        if config.is_favorite(filename):
+            config.remove_favorite(filename)
+            self.notify(f"Removed from favorites: {filename}")
+        else:
+            config.add_favorite(filename)
+            self.notify(f"Added to favorites: {filename}")
+
+        # Update the button
+        btn = self.query_one("#favorite-btn", Button)
+        is_favorite = config.is_favorite(filename)
+        btn.label = "★ Favorite" if not is_favorite else "☆ Unfavorite"
+        btn.variant = "warning" if is_favorite else "default"
+
+        # Update title
+        title = self.query_one(".title", Static)
+        star = "★ " if is_favorite else ""
+        title.update(f"[bold]{star}{filename}[/bold]")
+
+    def action_go_back(self) -> None:
+        """Go back to the previous screen."""
+        self.app.pop_screen()